дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-21 09:00:49 +02:00
Порівняти коміти
201
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
55cb9f11f7 | ||
|
|
1000ef0fa0 | ||
|
|
654da3e1ef | ||
|
|
ba6ccaf9b2 | ||
|
|
3ec631f0c0 | ||
|
|
f64796607c | ||
|
|
5baaf5b7de | ||
|
|
95f88f6ffb | ||
|
|
06b7c3a826 | ||
|
|
e9335f032d | ||
|
|
d09fdc8c7e | ||
|
|
54e69973c8 | ||
|
|
91d37aa4bf | ||
|
|
e149ba2ab3 | ||
|
|
fc6de7d0e4 | ||
|
|
76ef8c9b05 | ||
|
|
0344553652 | ||
|
|
cf15013b49 | ||
|
|
eb985cda28 | ||
|
|
212ee03d71 | ||
|
|
b721fe09db | ||
|
|
6ffb4c22f0 | ||
|
|
dc38b0b081 | ||
|
|
3cbc9d7f75 | ||
|
|
2ec2a6c262 | ||
|
|
11dca3ab42 | ||
|
|
f9044dcc00 | ||
|
|
a7d7293b2f | ||
|
|
a5280c50f7 | ||
|
|
dd0578979a | ||
|
|
e96b0483ac | ||
|
|
608b292510 | ||
|
|
dd6d83fd2c | ||
|
|
b89febd61f | ||
|
|
99ca421a0e | ||
|
|
e6fd000bb7 | ||
|
|
9e2e229a56 | ||
|
|
60564f4b33 | ||
|
|
db1fff2f6a | ||
|
|
1c09fbe28a | ||
|
|
834fac89b4 | ||
|
|
844e290729 | ||
|
|
a1ab5b6c29 | ||
|
|
9797598864 | ||
|
|
21a8856dfd | ||
|
|
9c523bba36 | ||
|
|
8f3e20cdf8 | ||
|
|
affee5452d | ||
|
|
4149c1b5d7 | ||
|
|
52010b95b1 | ||
|
|
9e530a9024 | ||
|
|
aebc7f7f99 | ||
|
|
1586738468 | ||
|
|
7ec5080047 | ||
|
|
06d7487913 | ||
|
|
e676138956 | ||
|
|
1a1ea14b9c | ||
|
|
5c0917b849 | ||
|
|
19f2c0ef5d | ||
|
|
8c696b8fe7 | ||
|
|
deecdbbf4f | ||
|
|
802400c324 | ||
|
|
edc6a522ee | ||
|
|
0c7a278ca6 | ||
|
|
8c93136063 | ||
|
|
e20e7b04bc | ||
|
|
f325e8c9d6 | ||
|
|
84edcc03a4 | ||
|
|
4146ca2041 | ||
|
|
105c37360b | ||
|
|
567b432468 | ||
|
|
f13d2b46cd | ||
|
|
266bd35a3d | ||
|
|
330d45279b | ||
|
|
af0e9c9a55 | ||
|
|
0e1a5e47d3 | ||
|
|
5226443670 | ||
|
|
07191394a5 | ||
|
|
882a08c5a4 | ||
|
|
8b5a9f582f | ||
|
|
1a430e5fdb | ||
|
|
7b2ba44a8d | ||
|
|
e6905f288e | ||
|
|
1828601b2a | ||
|
|
463b13b6b5 | ||
|
|
84cdfa2136 | ||
|
|
2bb93366bb | ||
|
|
7ee0a99853 | ||
|
|
7f21fdbe4d | ||
|
|
d47e9688cb | ||
|
|
94e318e740 | ||
|
|
6303cd5aef | ||
|
|
748f567abc | ||
|
|
9fe1dd8d7b | ||
|
|
c0b243f020 | ||
|
|
96f3818bf2 | ||
|
|
adf17d030e | ||
|
|
815bebf4ec | ||
|
|
2b75b79ea0 | ||
|
|
2c6329012a | ||
|
|
f40bcd747f | ||
|
|
c752f007be | ||
|
|
bcdff6886f | ||
|
|
b7e9276b0f | ||
|
|
6023e391bc | ||
|
|
3d80e661b7 | ||
|
|
b66439ceda | ||
|
|
899fe888b7 | ||
|
|
e7de2aaf6d | ||
|
|
9293b13737 | ||
|
|
d1f79d05b3 | ||
|
|
176c43c908 | ||
|
|
20b6b0aed5 | ||
|
|
101a0862e4 | ||
|
|
b48f0b6071 | ||
|
|
a9b16c3e06 | ||
|
|
abd55f88b5 | ||
|
|
dac4db0994 | ||
|
|
b0d0ea868b | ||
|
|
d86ff872af | ||
|
|
dbef3cdc96 | ||
|
|
c483c3b76f | ||
|
|
da79a73def | ||
|
|
2cc54b35f6 | ||
|
|
097221c1b3 | ||
|
|
1bb4ffe6b2 | ||
|
|
51e525336b | ||
|
|
1b47bc2c14 | ||
|
|
aa1326496b | ||
|
|
7850429174 | ||
|
|
3dd5c75fa0 | ||
|
|
36ecb53159 | ||
|
|
006405ca11 | ||
|
|
40b95650cf | ||
|
|
0a571c0b4d | ||
|
|
b1f88bf79c | ||
|
|
0a6b3d011f | ||
|
|
fd9b20fa05 | ||
|
|
4f5622d72c | ||
|
|
f4a7a7bafb | ||
|
|
737afc6a8d | ||
|
|
6bf75155b6 | ||
|
|
bbedf7e1f6 | ||
|
|
42fd0fa8e0 | ||
|
|
97a41ae983 | ||
|
|
f29903b698 | ||
|
|
610fe23f88 | ||
|
|
59376b9718 | ||
|
|
170fd735dd | ||
|
|
e0ae9e764c | ||
|
|
19c1b72650 | ||
|
|
06ff2e51c3 | ||
|
|
6ae31b8148 | ||
|
|
3783b601b5 | ||
|
|
37044dcd89 | ||
|
|
1a2adab237 | ||
|
|
9ed87d77a7 | ||
|
|
9f4731189d | ||
|
|
92ccfac192 | ||
|
|
60d335eec0 | ||
|
|
a679e8086f | ||
|
|
4c20aa5c8d | ||
|
|
d19d74120b | ||
|
|
4e1cec5233 | ||
|
|
150eacc3de | ||
|
|
d1cc3cf68a | ||
|
|
7c00ce4fa1 | ||
|
|
6539a95cb8 | ||
|
|
08613ca800 | ||
|
|
1ad8b06a1a | ||
|
|
2ca0e195e5 | ||
|
|
750d35dd6e | ||
|
|
f0273690b9 | ||
|
|
04611c0388 | ||
|
|
1cfc71ae58 | ||
|
|
8daaef38d9 | ||
|
|
efd4e454ee | ||
|
|
0379c37a49 | ||
|
|
98da80b2b3 | ||
|
|
5c2e7ff92a | ||
|
|
e86a853048 | ||
|
|
fd8f0eb99c | ||
|
|
121e1fa535 | ||
|
|
5859cf9f5b | ||
|
|
21b187f2d5 | ||
|
|
121d7edc15 | ||
|
|
b9256a7260 | ||
|
|
47b4cb55ba | ||
|
|
da1bcd67cd | ||
|
|
67a4797cf4 | ||
|
|
39523bc419 | ||
|
|
639c76d54c | ||
|
|
d5f29ea256 | ||
|
|
f9455549a7 | ||
|
|
dd14e8b040 | ||
|
|
efce16d45d | ||
|
|
977ce62bf0 | ||
|
|
479123dcf3 | ||
|
|
09301ca12d | ||
|
|
485c1ac40b | ||
|
|
6d756ec472 |
No files matched your search
Створено
+19
@@ -4156,6 +4156,8 @@ dependencies = [
|
||||
"ide-vcs",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
"rustix",
|
||||
"semver",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"specta",
|
||||
@@ -4357,6 +4359,20 @@ dependencies = [
|
||||
"which",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-drag-out"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"gtk",
|
||||
"objc2 0.6.5",
|
||||
"objc2-app-kit 0.3.2",
|
||||
"objc2-foundation 0.3.2",
|
||||
"raw-window-handle",
|
||||
"tempfile",
|
||||
"windows",
|
||||
"windows-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ide-extension"
|
||||
version = "0.1.49"
|
||||
@@ -4511,6 +4527,7 @@ dependencies = [
|
||||
name = "ide-http"
|
||||
version = "0.1.49"
|
||||
dependencies = [
|
||||
"hyper-util",
|
||||
"ide-core",
|
||||
"ide-vfs",
|
||||
"parking_lot",
|
||||
@@ -5017,6 +5034,7 @@ dependencies = [
|
||||
"ignore",
|
||||
"notify",
|
||||
"parking_lot",
|
||||
"rayon",
|
||||
"rustix",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -6696,6 +6714,7 @@ dependencies = [
|
||||
"ide-dap",
|
||||
"ide-db",
|
||||
"ide-docker",
|
||||
"ide-drag-out",
|
||||
"ide-extension",
|
||||
"ide-fonts",
|
||||
"ide-github",
|
||||
|
||||
@@ -38,6 +38,7 @@ ide-web = { path = "crates/ide-web" }
|
||||
ide-spell = { path = "crates/ide-spell" }
|
||||
ide-agent = { path = "crates/ide-agent" }
|
||||
ide-clipboard = { path = "crates/ide-clipboard" }
|
||||
ide-drag-out = { path = "crates/ide-drag-out" }
|
||||
ide-fonts = { path = "crates/ide-fonts" }
|
||||
ide-ssh = { path = "crates/ide-ssh" }
|
||||
ide-remote = { path = "crates/ide-remote" }
|
||||
|
||||
@@ -25,6 +25,10 @@ dunce.workspace = true
|
||||
uuid.workspace = true
|
||||
tempfile.workspace = true
|
||||
which = "8"
|
||||
semver = "1"
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
rustix = { version = "1", features = ["fs"] }
|
||||
|
||||
[dev-dependencies]
|
||||
tokio = { workspace = true, features = ["test-util"] }
|
||||
@@ -51,7 +51,7 @@ async fn run_once(
|
||||
move || launch.resolve_for_launch_with_copilot_env(&root, strip_ambient)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
.map_err(|e| e.to_string())??;
|
||||
let cwd = dunce::canonicalize(&root).unwrap_or(root);
|
||||
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
|
||||
let client = Dialect::wrap(updates.clone());
|
||||
|
||||
@@ -0,0 +1,395 @@
|
||||
//! Checks and updates only the global npm installation selected by the agent launcher.
|
||||
use crate::{AgentManager, AgentSource, provider};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
use specta::Type;
|
||||
use std::{
|
||||
fs, io,
|
||||
path::{Path, PathBuf},
|
||||
process::Command,
|
||||
};
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
pub struct AgentCliOffer {
|
||||
pub current: String,
|
||||
pub latest: String,
|
||||
pub prefix: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "status", rename_all = "camelCase")]
|
||||
pub enum AgentCliUpdateResult {
|
||||
Available(AgentCliOffer),
|
||||
Permission(AgentCliOffer),
|
||||
Current { current: String },
|
||||
Channel { current: String },
|
||||
Updated { current: String },
|
||||
Unmanaged,
|
||||
Error { code: String },
|
||||
}
|
||||
|
||||
pub(crate) fn package(id: &str) -> Option<&'static str> {
|
||||
Some(match id {
|
||||
"claude" => "@anthropic-ai/claude-code",
|
||||
"codex" => "@openai/codex",
|
||||
"gemini" => "@google/gemini-cli",
|
||||
"opencode" => "opencode-ai",
|
||||
"copilot" => "@github/copilot",
|
||||
"qwen" => "@qwen-code/qwen-code",
|
||||
"auggie" => "@augmentcode/auggie",
|
||||
"qoder" => "@qoder-ai/qodercli",
|
||||
"omp" => "@oh-my-pi/pi-coding-agent",
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
impl AgentManager {
|
||||
pub fn cli_update(
|
||||
&self,
|
||||
id: &str,
|
||||
offer: Option<&AgentCliOffer>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
let spec = self.shared.spec(id).ok_or_else(|| IdeError::invalid(format!("unknown agent {id}")))?;
|
||||
let (Some(pkg), Some(builtin)) = (package(id), provider::builtin_spec(id)) else {
|
||||
return Ok(AgentCliUpdateResult::Unmanaged);
|
||||
};
|
||||
if spec.source != AgentSource::Builtin {
|
||||
return Ok(AgentCliUpdateResult::Unmanaged);
|
||||
}
|
||||
let Ok(npm) = which::which("npm") else { return Ok(AgentCliUpdateResult::Unmanaged) };
|
||||
let program = spec.resolve_for_launch(&self.shared.paths.project_root).command;
|
||||
match maintain(&npm, Path::new(&program), &builtin.command, pkg, offer, cancel) {
|
||||
Err(e) if e.kind == ErrorKind::Unavailable => Ok(AgentCliUpdateResult::Error { code: e.message }),
|
||||
result => result,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Installation {
|
||||
modules: PathBuf,
|
||||
folder: PathBuf,
|
||||
link: PathBuf,
|
||||
}
|
||||
|
||||
impl Installation {
|
||||
fn at(prefix: &Path, pkg: &str, bin: &str) -> Self {
|
||||
let modules = prefix.join(if cfg!(windows) { "node_modules" } else { "lib/node_modules" });
|
||||
let link = if cfg!(windows) { prefix.join(format!("{bin}.cmd")) } else { prefix.join("bin").join(bin) };
|
||||
Self { folder: modules.join(pkg), modules, link }
|
||||
}
|
||||
|
||||
fn version(&self, program: &Path, pkg: &str, bin: &str) -> IdeResult<Option<String>> {
|
||||
if !program.is_absolute() || !self.folder.try_exists()? || !self.link.try_exists()? || !program.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let folder = dunce::canonicalize(&self.folder)?;
|
||||
if fs::symlink_metadata(&self.folder)?.is_symlink()
|
||||
|| dunce::canonicalize(program)? != dunce::canonicalize(&self.link)?
|
||||
{
|
||||
return Ok(None);
|
||||
}
|
||||
let manifest = self.folder.join("package.json");
|
||||
if !manifest.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let manifest: Value = serde_json::from_slice(&fs::read(manifest)?)
|
||||
.map_err(|_| IdeError::invalid("Invalid npm package manifest"))?;
|
||||
let entry = manifest["bin"].as_str().or_else(|| manifest["bin"][bin].as_str());
|
||||
let Some(entry) = entry.filter(|_| manifest["name"] == pkg) else { return Ok(None) };
|
||||
let Some(version) = manifest["version"].as_str() else {
|
||||
return Err(IdeError::invalid("Missing npm package version"));
|
||||
};
|
||||
let entry = folder.join(entry);
|
||||
if !entry.try_exists()? {
|
||||
return Ok(None);
|
||||
}
|
||||
let entry = dunce::canonicalize(entry)?;
|
||||
if !entry.starts_with(&folder) {
|
||||
return Ok(None);
|
||||
}
|
||||
#[cfg(unix)]
|
||||
let owns = fs::symlink_metadata(&self.link)?.is_symlink() && dunce::canonicalize(&self.link)? == entry;
|
||||
#[cfg(windows)]
|
||||
let owns = {
|
||||
let prefix = dunce::canonicalize(self.link.parent().unwrap())?;
|
||||
let Ok(target) = entry.strip_prefix(prefix) else { return Ok(None) };
|
||||
let needle = format!("%dp0%\\{}\"", target.display()).to_lowercase();
|
||||
fs::read_to_string(&self.link)?.replace('/', "\\").to_lowercase().contains(&needle)
|
||||
};
|
||||
Ok(owns.then(|| version.to_owned()))
|
||||
}
|
||||
|
||||
fn writable(&self) -> io::Result<bool> {
|
||||
for dir in [&*self.folder, self.folder.parent().unwrap(), &self.modules, self.link.parent().unwrap()] {
|
||||
#[cfg(unix)]
|
||||
let access: io::Result<()> =
|
||||
rustix::fs::accessat(rustix::fs::CWD, dir, rustix::fs::Access::WRITE_OK, rustix::fs::AtFlags::empty())
|
||||
.map_err(Into::into);
|
||||
#[cfg(windows)]
|
||||
let access = tempfile::tempfile_in(dir).map(drop);
|
||||
match access {
|
||||
Err(e) if matches!(e.kind(), io::ErrorKind::PermissionDenied | io::ErrorKind::ReadOnlyFilesystem) => {
|
||||
return Ok(false);
|
||||
}
|
||||
other => other?,
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
}
|
||||
|
||||
fn stable(version: &str) -> Option<semver::Version> {
|
||||
semver::Version::parse(version).ok().filter(|v| v.pre.is_empty() && v.build.is_empty())
|
||||
}
|
||||
|
||||
fn maintain(
|
||||
npm: &Path,
|
||||
program: &Path,
|
||||
bin: &str,
|
||||
pkg: &str,
|
||||
approved: Option<&AgentCliOffer>,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
use AgentCliUpdateResult::*;
|
||||
let run = |args: &[&str]| {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let mut cmd = Command::new(npm);
|
||||
cmd.args(args)
|
||||
.current_dir(npm.parent().unwrap())
|
||||
.env("NPM_CONFIG_UPDATE_NOTIFIER", "false")
|
||||
.env("NPM_CONFIG_LOGLEVEL", "error");
|
||||
ide_tools::run_streamed(cmd, cancel, &|_| {}).map_err(|e| {
|
||||
if e.kind == ErrorKind::Cancelled {
|
||||
return e;
|
||||
}
|
||||
// npm diagnostics can contain private registry URLs; expose only known codes.
|
||||
let code = e
|
||||
.message
|
||||
.split(|c: char| !c.is_ascii_alphanumeric() && c != '_')
|
||||
.find(|w| {
|
||||
matches!(
|
||||
*w,
|
||||
"EACCES"
|
||||
| "EPERM"
|
||||
| "EROFS"
|
||||
| "ENOTFOUND"
|
||||
| "EAI_AGAIN"
|
||||
| "ETIMEDOUT"
|
||||
| "E404"
|
||||
| "E401"
|
||||
| "E403"
|
||||
)
|
||||
})
|
||||
.unwrap_or("npm");
|
||||
IdeError::unavailable(code)
|
||||
})
|
||||
};
|
||||
let output = run(&["prefix", "-g"])?;
|
||||
let prefix = Path::new(output.trim_end());
|
||||
if !prefix.is_absolute() {
|
||||
return Err(IdeError::invalid("Invalid npm global prefix"));
|
||||
}
|
||||
let installation = Installation::at(prefix, pkg, bin);
|
||||
let Some(current) = installation.version(program, pkg, bin)? else { return Ok(Unmanaged) };
|
||||
let latest: String = serde_json::from_str(&run(&["view", &format!("{pkg}@latest"), "version", "--json"])?)
|
||||
.map_err(|_| IdeError::invalid("Invalid npm version response"))?;
|
||||
let (Some(before), Some(after)) = (stable(¤t), stable(&latest)) else {
|
||||
return Ok(Channel { current });
|
||||
};
|
||||
if before >= after {
|
||||
return Ok(Current { current });
|
||||
}
|
||||
let offer = AgentCliOffer { current, latest, prefix: prefix.to_owned() };
|
||||
if !installation.writable()? {
|
||||
return Ok(Permission(offer));
|
||||
}
|
||||
if approved != Some(&offer) {
|
||||
return Ok(Available(offer));
|
||||
}
|
||||
run(&[
|
||||
"install",
|
||||
"-g",
|
||||
"--prefix",
|
||||
prefix.to_str().unwrap(),
|
||||
"--no-audit",
|
||||
"--no-fund",
|
||||
&format!("{pkg}@{}", offer.latest),
|
||||
])?;
|
||||
if installation.version(program, pkg, bin)?.as_ref() != Some(&offer.latest) {
|
||||
return Err(IdeError::invalid("npm installation verification failed"));
|
||||
}
|
||||
Ok(Updated { current: offer.latest })
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
use tempfile::TempDir;
|
||||
|
||||
const PKG: &str = "@anthropic-ai/claude-code";
|
||||
|
||||
struct Fixture {
|
||||
root: TempDir,
|
||||
install: Installation,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
fn new() -> Self {
|
||||
let root = tempfile::Builder::new().prefix("全局 prefix ").tempdir().unwrap();
|
||||
let install = Installation::at(root.path(), PKG, "claude");
|
||||
fs::create_dir_all(&install.folder).unwrap();
|
||||
fs::create_dir_all(install.link.parent().unwrap()).unwrap();
|
||||
fs::write(install.folder.join("entry.js"), "").unwrap();
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::symlink(install.folder.join("entry.js"), &install.link).unwrap();
|
||||
#[cfg(windows)]
|
||||
fs::write(&install.link, r#"@"%dp0%\node_modules\@anthropic-ai\claude-code\entry.js""#).unwrap();
|
||||
let fixture = Self { root, install };
|
||||
fixture.manifest(PKG, "2.1.9");
|
||||
fixture
|
||||
}
|
||||
|
||||
fn manifest(&self, name: &str, version: &str) {
|
||||
fs::write(
|
||||
self.install.folder.join("package.json"),
|
||||
json!({"name":name,"version":version,"bin":{"claude":"entry.js"}}).to_string(),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
fn version(&self) -> Option<String> {
|
||||
self.install.version(&self.install.link, PKG, "claude").unwrap()
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn npm(&self, script: &str) -> PathBuf {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path = self.root.path().join("npm");
|
||||
fs::write(&path, format!("#!/bin/sh\nset -eu\n{script}\n")).unwrap();
|
||||
fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
path
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn requires_the_selected_install_and_its_exact_package_entry() {
|
||||
let f = Fixture::new();
|
||||
assert_eq!(f.version().as_deref(), Some("2.1.9"));
|
||||
let other = f.root.path().join("other");
|
||||
fs::write(&other, "").unwrap();
|
||||
assert_eq!(f.install.version(&other, PKG, "claude").unwrap(), None);
|
||||
f.manifest("other-package", "2.1.9");
|
||||
assert_eq!(f.version(), None);
|
||||
f.manifest(PKG, "2.1.9");
|
||||
fs::remove_file(&f.install.link).unwrap();
|
||||
#[cfg(unix)]
|
||||
std::os::unix::fs::symlink(&other, &f.install.link).unwrap();
|
||||
#[cfg(windows)]
|
||||
fs::write(&f.install.link, r#"@"%dp0%\other""#).unwrap();
|
||||
assert_eq!(f.version(), None);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
const NPM: &str = r#"case "$1" in
|
||||
prefix) pwd -P ;;
|
||||
view) cat latest ;;
|
||||
install)
|
||||
test "$2" = "-g" && test "$3" = "--prefix" && test "$4" = "$(pwd -P)"
|
||||
test "$7" = "@anthropic-ai/[email protected]"
|
||||
cp updated.json "$4/lib/node_modules/@anthropic-ai/claude-code/package.json"
|
||||
touch installed ;;
|
||||
*) exit 2 ;;
|
||||
esac"#;
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn installs_only_the_confirmed_offer_and_rechecks_ownership() {
|
||||
use AgentCliUpdateResult::*;
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(NPM);
|
||||
let cancel = CancellationToken::new();
|
||||
let run =
|
||||
|offer: Option<&AgentCliOffer>| maintain(&npm, &f.install.link, "claude", PKG, offer, &cancel).unwrap();
|
||||
let latest = f.root.path().join("latest");
|
||||
fs::write(&latest, r#""2.1.12""#).unwrap();
|
||||
let Available(offer) = run(None) else { panic!("expected an offer") };
|
||||
for different in [
|
||||
AgentCliOffer { prefix: PathBuf::from("/other"), ..offer.clone() },
|
||||
AgentCliOffer { current: "2.0.0".into(), ..offer.clone() },
|
||||
] {
|
||||
assert_eq!(run(Some(&different)), Available(offer.clone()));
|
||||
}
|
||||
fs::write(&latest, r#""2.2.0""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Available(new) if new.latest == "2.2.0"));
|
||||
fs::write(&latest, r#""2.0.0""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Current { .. }));
|
||||
fs::write(&latest, r#""2.2.0-beta.1""#).unwrap();
|
||||
assert!(matches!(run(Some(&offer)), Channel { .. }));
|
||||
fs::write(&latest, r#""2.1.12""#).unwrap();
|
||||
f.manifest("other-package", "2.1.9");
|
||||
assert_eq!(run(Some(&offer)), Unmanaged);
|
||||
assert!(!f.root.path().join("installed").exists());
|
||||
f.manifest(PKG, "2.1.12");
|
||||
fs::copy(f.install.folder.join("package.json"), f.root.path().join("updated.json")).unwrap();
|
||||
f.manifest(PKG, "2.1.9");
|
||||
assert_eq!(run(Some(&offer)), Updated { current: "2.1.12".into() });
|
||||
assert!(f.root.path().join("installed").exists());
|
||||
assert_eq!(run(None), Current { current: "2.1.12".into() });
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn permission_failure_never_starts_an_install() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(NPM);
|
||||
fs::write(f.root.path().join("latest"), r#""2.1.12""#).unwrap();
|
||||
let run = |offer: Option<&AgentCliOffer>| {
|
||||
maintain(&npm, &f.install.link, "claude", PKG, offer, &CancellationToken::new()).unwrap()
|
||||
};
|
||||
let AgentCliUpdateResult::Available(offer) = run(None) else { panic!("expected an offer") };
|
||||
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o555)).unwrap();
|
||||
// root can write even when no mode bit grants write permission.
|
||||
if tempfile::tempfile_in(&f.install.folder).is_err() {
|
||||
assert_eq!(run(Some(&offer)), AgentCliUpdateResult::Permission(offer));
|
||||
}
|
||||
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o755)).unwrap();
|
||||
assert!(!f.root.path().join("installed").exists());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn cancellation_stops_a_running_npm_process() {
|
||||
use std::time::{Duration, Instant};
|
||||
let f = Fixture::new();
|
||||
let npm = f.npm(
|
||||
r#"case "$1" in
|
||||
prefix) pwd -P ;;
|
||||
view) echo '"2.1.12"' ;;
|
||||
install) touch started; exec sleep 30 ;;
|
||||
esac"#,
|
||||
);
|
||||
let cancel = CancellationToken::new();
|
||||
let AgentCliUpdateResult::Available(offer) =
|
||||
maintain(&npm, &f.install.link, "claude", PKG, None, &cancel).unwrap()
|
||||
else {
|
||||
panic!("expected an offer")
|
||||
};
|
||||
let started = f.root.path().join("started");
|
||||
std::thread::scope(|s| {
|
||||
let op = s.spawn(|| maintain(&npm, &f.install.link, "claude", PKG, Some(&offer), &cancel));
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
while !started.exists() && Instant::now() < deadline {
|
||||
std::thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
cancel.cancel();
|
||||
assert!(started.exists());
|
||||
assert_eq!(op.join().unwrap().unwrap_err().kind, ErrorKind::Cancelled);
|
||||
});
|
||||
assert_eq!(f.version().as_deref(), Some("2.1.9"));
|
||||
}
|
||||
}
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
use crate::model::{
|
||||
AgentCommand, AgentCommandSource, AgentConfigOption, AgentConfigValue, AgentConfigVia, AgentCost, AgentLimit,
|
||||
AgentModelPricing, AgentUsage,
|
||||
AgentModelPricing, AgentTokens, AgentUsage,
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
@@ -272,6 +272,18 @@ pub(crate) fn usage_of(update: &Value) -> Option<AgentUsage> {
|
||||
Some(AgentUsage { used: tokens("used")?, size: tokens("size").filter(|s| *s > 0)?, cost })
|
||||
}
|
||||
|
||||
/// The `usage` of a `session/prompt` result: `{ inputTokens, cachedReadTokens, outputTokens }`.
|
||||
pub(crate) fn tokens_of(result: &Value) -> Option<AgentTokens> {
|
||||
let usage = result.get("usage")?;
|
||||
let tokens = |key: &str| usage.get(key).and_then(Value::as_u64).map_or(0, |n| u32::try_from(n).unwrap_or(u32::MAX));
|
||||
let tokens = AgentTokens {
|
||||
input: tokens("inputTokens"),
|
||||
cached: tokens("cachedReadTokens"),
|
||||
output: tokens("outputTokens"),
|
||||
};
|
||||
(tokens != AgentTokens::default()).then_some(tokens)
|
||||
}
|
||||
|
||||
/// The usage-limit windows a [`crate::LIMITS_UPDATE`] carries; malformed entries are skipped.
|
||||
pub(crate) fn limits_of(update: &Value) -> Vec<AgentLimit> {
|
||||
let limits = update.get("limits").and_then(Value::as_array).into_iter().flatten();
|
||||
@@ -368,6 +380,15 @@ mod tests {
|
||||
c.iter().map(|o| (o.id.as_str(), o.current.as_deref())).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_hermes_prompt_result_reports_the_turns_tokens() {
|
||||
let result = json!({"stopReason": "end_turn", "usage": {"cachedReadTokens": 51306, "inputTokens": 77284,
|
||||
"outputTokens": 509, "thoughtTokens": 0, "totalTokens": 77793}});
|
||||
assert_eq!(tokens_of(&result), Some(AgentTokens { input: 77284, cached: 51306, output: 509 }));
|
||||
assert_eq!(tokens_of(&json!({"stopReason": "end_turn"})), None);
|
||||
assert_eq!(tokens_of(&json!({"usage": {}})), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn config_options_win_over_the_older_fields() {
|
||||
let r = json!({
|
||||
|
||||
@@ -0,0 +1,111 @@
|
||||
//! Hermes Agent profiles on disk: `default` is the Hermes home itself, the others are
|
||||
//! `<home>/profiles/<name>` directories holding one of Hermes' identity files.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde::Serialize;
|
||||
use specta::Type;
|
||||
|
||||
const PROFILE_FILES: &[&str] = &["config.yaml", ".env", "SOUL.md", "profile.yaml", "auth.json", "state.db"];
|
||||
|
||||
/// Hermes' home directory (`~/.hermes`; `%LOCALAPPDATA%\hermes` on Windows).
|
||||
pub fn root(home: Option<&Path>) -> Option<PathBuf> {
|
||||
#[cfg(windows)]
|
||||
if let Some(local) = std::env::var_os("LOCALAPPDATA") {
|
||||
return Some(PathBuf::from(local).join("hermes"));
|
||||
}
|
||||
home.map(|h| h.join(".hermes"))
|
||||
}
|
||||
|
||||
/// The profile names under `root`: `default` first, then the others by name; none without `root`.
|
||||
pub fn profiles(root: &Path) -> Vec<String> {
|
||||
if !root.is_dir() {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut named: Vec<String> = std::fs::read_dir(root.join("profiles"))
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.flatten()
|
||||
.filter(|e| PROFILE_FILES.iter().any(|f| e.path().join(f).exists()))
|
||||
.filter_map(|e| e.file_name().to_str().map(str::to_owned))
|
||||
.filter(|name| name != "default")
|
||||
.collect();
|
||||
named.sort();
|
||||
std::iter::once("default".to_owned()).chain(named).collect()
|
||||
}
|
||||
|
||||
/// A profile and the name Hermes shows for it (`hermes profile list`).
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Type)]
|
||||
pub struct HermesProfile {
|
||||
/// What `hermes -p` takes; `default` is the Hermes home itself.
|
||||
pub name: String,
|
||||
/// `display_name` from the profile's `profile.yaml`, else the name.
|
||||
pub label: String,
|
||||
}
|
||||
|
||||
/// [`profiles`] with the names Hermes shows for them.
|
||||
pub fn labeled_profiles(root: &Path) -> Vec<HermesProfile> {
|
||||
profiles(root)
|
||||
.into_iter()
|
||||
.map(|name| {
|
||||
let home = if name == "default" { root.to_path_buf() } else { root.join("profiles").join(&name) };
|
||||
let label = display_name(&home).unwrap_or_else(|| name.clone());
|
||||
HermesProfile { name, label }
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The top-level `display_name:` of `<home>/profile.yaml`, the only key read (no YAML parser).
|
||||
fn display_name(home: &Path) -> Option<String> {
|
||||
let text = std::fs::read_to_string(home.join("profile.yaml")).ok()?;
|
||||
let value = text.lines().find_map(|l| l.strip_prefix("display_name:"))?;
|
||||
let value = value.trim().trim_matches(['"', '\'']).trim();
|
||||
(!value.is_empty()).then(|| value.to_owned())
|
||||
}
|
||||
|
||||
/// The home of the profile an agent id stands for: `hermes` and `hermes-default` are the
|
||||
/// default profile, `hermes-<slug>` the profile whose name slugifies to `<slug>`.
|
||||
pub fn profile_home(root: &Path, provider: &str) -> Option<PathBuf> {
|
||||
let slug = match provider {
|
||||
"hermes" | "hermes-default" => return Some(root.to_path_buf()),
|
||||
_ => provider.strip_prefix("hermes-")?,
|
||||
};
|
||||
profiles(root).into_iter().find(|p| crate::provider::slugify_id(p) == slug).map(|p| root.join("profiles").join(p))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn lists_default_and_profiles_with_an_identity_file() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
assert!(profiles(&dir.path().join("missing")).is_empty());
|
||||
let root = dir.path().join(".hermes");
|
||||
std::fs::create_dir_all(root.join("profiles/empty")).unwrap();
|
||||
assert_eq!(profiles(&root), ["default"]);
|
||||
for (name, file) in [("work", "config.yaml"), ("Dom 2", "SOUL.md"), ("db", "state.db")] {
|
||||
std::fs::create_dir_all(root.join("profiles").join(name)).unwrap();
|
||||
std::fs::write(root.join("profiles").join(name).join(file), "").unwrap();
|
||||
}
|
||||
std::fs::write(root.join("profiles/stray.yaml"), "").unwrap();
|
||||
assert_eq!(profiles(&root), ["default", "Dom 2", "db", "work"]);
|
||||
assert_eq!(profile_home(&root, "hermes"), Some(root.clone()));
|
||||
assert_eq!(profile_home(&root, "hermes-dom-2"), Some(root.join("profiles/Dom 2")));
|
||||
assert_eq!(profile_home(&root, "hermes-empty"), None);
|
||||
assert_eq!(profile_home(&root, "claude"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn labels_profiles_with_their_display_name() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().join(".hermes");
|
||||
std::fs::create_dir_all(root.join("profiles/work")).unwrap();
|
||||
std::fs::write(root.join("profile.yaml"), "description: mine\ndisplay_name: \"qb\"\n").unwrap();
|
||||
std::fs::write(root.join("profiles/work/profile.yaml"), "ui_meta:\n display_name: nested\n").unwrap();
|
||||
let label = |name: &str, label: &str| HermesProfile { name: name.into(), label: label.into() };
|
||||
assert_eq!(labeled_profiles(&root), [label("default", "qb"), label("work", "work")]);
|
||||
std::fs::remove_file(root.join("profile.yaml")).unwrap();
|
||||
assert_eq!(labeled_profiles(&root)[0], label("default", "default"));
|
||||
}
|
||||
}
|
||||
@@ -10,10 +10,12 @@
|
||||
mod acp;
|
||||
mod async_questions;
|
||||
mod catalogs;
|
||||
mod cli_update;
|
||||
mod config;
|
||||
mod conversation;
|
||||
mod elicitation;
|
||||
mod external;
|
||||
pub mod hermes;
|
||||
pub mod mcp;
|
||||
mod model;
|
||||
mod native;
|
||||
@@ -26,6 +28,7 @@ mod timeline;
|
||||
mod worktree;
|
||||
|
||||
pub use catalogs::AgentCatalogs;
|
||||
pub use cli_update::{AgentCliOffer, AgentCliUpdateResult};
|
||||
pub use external::ExternalSession;
|
||||
pub use model::*;
|
||||
|
||||
@@ -131,6 +134,7 @@ pub type McpExecutableFn = dyn Fn() -> Option<PathBuf> + Send + Sync;
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
|
||||
struct CopilotBinaryKey {
|
||||
command: String,
|
||||
github_account: Option<String>,
|
||||
modified: Option<std::time::SystemTime>,
|
||||
len: Option<u64>,
|
||||
}
|
||||
@@ -139,7 +143,7 @@ struct Shared {
|
||||
paths: AgentPaths,
|
||||
runtime: tokio::runtime::Handle,
|
||||
connector: Connector,
|
||||
sink: RwLock<Option<AgentSink>>,
|
||||
sinks: RwLock<HashMap<String, AgentSink>>,
|
||||
security: RwLock<Option<SecurityHook>>,
|
||||
new_task_approvals: RwLock<Option<NewTaskApprovalsHook>>,
|
||||
known: Arc<Mutex<HashMap<String, Known>>>,
|
||||
@@ -192,6 +196,7 @@ impl Shared {
|
||||
let metadata = std::fs::metadata(&executable).ok();
|
||||
CopilotBinaryKey {
|
||||
command: executable.to_string_lossy().into_owned(),
|
||||
github_account: provider::copilot_github_account(&spec.env),
|
||||
modified: metadata.as_ref().and_then(|m| m.modified().ok()),
|
||||
len: metadata.as_ref().map(std::fs::Metadata::len),
|
||||
}
|
||||
@@ -210,10 +215,12 @@ impl Shared {
|
||||
}
|
||||
|
||||
fn emit(&self, event: AgentEvent) {
|
||||
let sink = self.sink.read().clone();
|
||||
if let Some(sink) = sink {
|
||||
sink(event);
|
||||
let mut sinks: Vec<_> = self.sinks.read().values().cloned().collect();
|
||||
let Some(last) = sinks.pop() else { return };
|
||||
for sink in sinks {
|
||||
sink(event.clone());
|
||||
}
|
||||
last(event);
|
||||
}
|
||||
|
||||
/// The MCP servers passed to a session, and the names of the ones off for it.
|
||||
@@ -558,7 +565,7 @@ impl AgentManager {
|
||||
paths,
|
||||
runtime,
|
||||
connector,
|
||||
sink: RwLock::new(None),
|
||||
sinks: RwLock::new(HashMap::new()),
|
||||
security: RwLock::new(None),
|
||||
new_task_approvals: RwLock::new(None),
|
||||
known,
|
||||
@@ -601,12 +608,22 @@ impl AgentManager {
|
||||
|
||||
/// Routes events to `sink` (replacing the previous subscriber); returns every task.
|
||||
pub fn subscribe(&self, sink: AgentSink) -> Vec<AgentTask> {
|
||||
*self.shared.sink.write() = Some(sink);
|
||||
self.subscribe_as("", sink)
|
||||
}
|
||||
|
||||
/// Routes events to `sink` too, replacing only the sink `subscriber` (a view of the project) had.
|
||||
pub fn subscribe_as(&self, subscriber: &str, sink: AgentSink) -> Vec<AgentTask> {
|
||||
self.shared.sinks.write().insert(subscriber.to_owned(), sink);
|
||||
let mut tasks: Vec<AgentTask> = self.tasks.read().values().map(|t| t.state.lock().snapshot()).collect();
|
||||
tasks.sort_by(|a, b| b.updated_ms.total_cmp(&a.updated_ms));
|
||||
tasks
|
||||
}
|
||||
|
||||
/// A closed view releases its sink, never the task or its agent process.
|
||||
pub fn unsubscribe(&self, subscriber: &str) {
|
||||
self.shared.sinks.write().remove(subscriber);
|
||||
}
|
||||
|
||||
/// Sets the callback used to read the active command execution security policy.
|
||||
pub fn set_security_hook(&self, hook: SecurityHook) {
|
||||
*self.shared.security.write() = Some(hook);
|
||||
@@ -709,7 +726,8 @@ impl AgentManager {
|
||||
|
||||
/// The slash commands to complete for `provider`, in `task`'s directory or (without one)
|
||||
/// in the project: what the agent offered last time there, unadvertised builtins,
|
||||
/// and, for Claude Code, skills and custom commands on disk it has not listed.
|
||||
/// and, for Claude Code, skills and custom commands on disk it has not listed (for Hermes,
|
||||
/// its profile's skills).
|
||||
pub async fn commands(&self, provider: &str, task: Option<&str>) -> IdeResult<Vec<AgentCommand>> {
|
||||
let (provider, offered, cwd) = match task {
|
||||
Some(id) => {
|
||||
@@ -743,10 +761,18 @@ impl AgentManager {
|
||||
offered.push(command);
|
||||
}
|
||||
}
|
||||
let home = self.shared.paths.home_dir.clone();
|
||||
if provider == "hermes" || provider.starts_with("hermes-") {
|
||||
let found = blocking(move || {
|
||||
let profile = hermes::root(home.as_deref()).and_then(|root| hermes::profile_home(&root, &provider));
|
||||
Ok(profile.map(|p| skills::hermes(&p)).unwrap_or_default())
|
||||
})
|
||||
.await?;
|
||||
return Ok(skills::merge(offered, found));
|
||||
}
|
||||
if provider != "claude" && provider != "claude-acp" {
|
||||
return Ok(offered);
|
||||
}
|
||||
let home = self.shared.paths.home_dir.clone();
|
||||
let found = blocking(move || Ok(skills::discover(&cwd, home.as_deref()))).await?;
|
||||
Ok(skills::merge(offered, found))
|
||||
}
|
||||
@@ -832,6 +858,7 @@ impl AgentManager {
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: BTreeMap::new(),
|
||||
stats: Box::default(),
|
||||
};
|
||||
let file = TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -949,6 +976,7 @@ impl AgentManager {
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
mcp_overrides: req.mcp_overrides,
|
||||
stats: Box::default(),
|
||||
};
|
||||
let file = TaskFile {
|
||||
task: task.clone(),
|
||||
@@ -1114,6 +1142,16 @@ impl AgentManager {
|
||||
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
|
||||
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let provider = task.state.lock().task.provider.clone();
|
||||
let discovered = self
|
||||
.shared
|
||||
.paths
|
||||
.catalogs
|
||||
.cached(&self.shared, &provider)
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.id == option && o.category.as_deref() == Some("model"))
|
||||
.cloned();
|
||||
let (target, change) = {
|
||||
let mut s = task.state.lock();
|
||||
let busy = s.busy;
|
||||
@@ -1134,17 +1172,19 @@ impl AgentManager {
|
||||
task.emit_task();
|
||||
return Ok(());
|
||||
}
|
||||
let target = s
|
||||
.task
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.id == option)
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
let session_target = s.task.config.iter().find(|o| o.id == option).cloned();
|
||||
let recovered_model = session_target.is_none();
|
||||
let target = match session_target {
|
||||
Some(target) => target,
|
||||
None if discovered.is_some() => discovered.unwrap(),
|
||||
None => return Err(IdeError::not_found("no such setting")),
|
||||
};
|
||||
if s.pending_model.is_some() && config::is_per_model_option(&target) {
|
||||
return Err(IdeError::invalid("This setting is not available on the selected model"));
|
||||
}
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
if recovered_model {
|
||||
(target, None)
|
||||
} else if !target.values.iter().any(|v| v.value == value) {
|
||||
if target.category.as_deref() != Some("model") {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
@@ -1316,6 +1356,7 @@ impl AgentManager {
|
||||
resets_ms: None,
|
||||
retry: None,
|
||||
background: Box::default(),
|
||||
stats: Box::default(),
|
||||
..s.task.clone()
|
||||
};
|
||||
TaskFile {
|
||||
@@ -1530,6 +1571,18 @@ impl AgentManager {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn context_usage(&self, id: &str) -> IdeResult<AgentContextUsage> {
|
||||
let task = self.task(id)?;
|
||||
let live = task.live.lock().clone().ok_or_else(|| IdeError::unavailable("the agent session is offline"))?;
|
||||
if !live.capabilities.context_usage {
|
||||
return Err(IdeError::unavailable("this agent does not report context details"));
|
||||
}
|
||||
live.peer
|
||||
.request("_openidea/context_usage", json!({ "sessionId": live.session }), None)
|
||||
.await
|
||||
.map_err(|error| IdeError::internal(task.describe(error)))
|
||||
}
|
||||
|
||||
/// Stops background task `background` of task `id`.
|
||||
pub async fn stop_background(&self, id: &str, background: &str) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
@@ -1961,7 +2014,7 @@ impl AgentManager {
|
||||
// What arrived after the last save (a subagent's late updates).
|
||||
task.persist();
|
||||
}
|
||||
*self.shared.sink.write() = None;
|
||||
self.shared.sinks.write().clear();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2653,7 +2706,13 @@ impl Task {
|
||||
.await;
|
||||
}
|
||||
match result {
|
||||
Ok(v) => Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned()),
|
||||
Ok(v) => {
|
||||
if let Some(tokens) = config::tokens_of(&v) {
|
||||
self.state.lock().task.stats.tokens = Some(tokens);
|
||||
self.emit_task();
|
||||
}
|
||||
Ok(v.get("stopReason").and_then(Value::as_str).unwrap_or("end_turn").to_owned())
|
||||
}
|
||||
Err(e) => Err(self.failure(e)),
|
||||
}
|
||||
}
|
||||
@@ -2780,9 +2839,12 @@ impl Task {
|
||||
pending_model: Option<&PendingModel>,
|
||||
) -> Result<Live, SessionOpenError> {
|
||||
let launch_cwd = cwd.to_path_buf();
|
||||
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
|
||||
.await
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
let mut spec = tokio::task::spawn_blocking(move || {
|
||||
spec.resolve_for_launch_with_copilot_env(&launch_cwd, provider::prefer_stored_copilot_auth())
|
||||
})
|
||||
.await
|
||||
.map_err(|e| SessionOpenError { message: e.to_string(), allow_acp_fallback: false })?
|
||||
.map_err(|e| SessionOpenError { message: e, allow_acp_fallback: false })?;
|
||||
if spec.driver == provider::Driver::Acp && provider::is_copilot_provider(provider_id) {
|
||||
let mcp_overrides = self.state.lock().task.mcp_overrides.clone();
|
||||
for name in self.shared.mcp_servers_off_for_session(provider_id, &mcp_overrides) {
|
||||
@@ -3187,6 +3249,17 @@ impl Task {
|
||||
return;
|
||||
}
|
||||
if kind == "session_info_update" {
|
||||
let depth = update.pointer("/_meta/hermes/sessionProvenance/compressionDepth").and_then(Value::as_u64);
|
||||
if let Some(depth) = depth.and_then(|d| u32::try_from(d).ok()) {
|
||||
let changed = {
|
||||
let mut s = self.state.lock();
|
||||
std::mem::replace(&mut s.task.stats.compressions, depth) != depth
|
||||
};
|
||||
if changed {
|
||||
self.persist();
|
||||
self.emit_task();
|
||||
}
|
||||
}
|
||||
// The agent's own title for the session replaces the first line of the prompt,
|
||||
// unless the user named the task.
|
||||
let title = update.get("title").and_then(Value::as_str).map(str::trim).filter(|t| !t.is_empty());
|
||||
@@ -3820,6 +3893,7 @@ fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
|
||||
rollback: meta("/openidea/rollback"),
|
||||
steer: steer_method(init).is_some(),
|
||||
background_tasks: meta("/openidea/backgroundTasks"),
|
||||
context_usage: meta("/openidea/contextUsage"),
|
||||
};
|
||||
(capabilities, init.prompt("embeddedContext"))
|
||||
}
|
||||
@@ -4038,7 +4112,7 @@ fn entry_event(
|
||||
entry: &AgentEntry,
|
||||
) -> AgentEvent {
|
||||
let text = match entry {
|
||||
AgentEntry::Agent { text } | AgentEntry::Thought { text } => Some(text),
|
||||
AgentEntry::Agent { text } | AgentEntry::Thought { text, .. } => Some(text),
|
||||
_ => None,
|
||||
};
|
||||
let Some(text) = text else {
|
||||
|
||||
@@ -45,6 +45,8 @@ pub struct AgentCapabilities {
|
||||
pub steer: bool,
|
||||
/// It reports its background tasks and stops them one by one.
|
||||
pub background_tasks: bool,
|
||||
/// The connected agent can report a breakdown of its context window.
|
||||
pub context_usage: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
@@ -108,6 +110,29 @@ pub struct AgentTask {
|
||||
/// 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>,
|
||||
/// Token counts of the last turn and context compressions, when the agent reports them.
|
||||
// Boxed so that `AgentEvent::Task` stays within clippy's `large_enum_variant` bound on Windows.
|
||||
#[serde(default)]
|
||||
pub stats: Box<AgentSessionStats>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentSessionStats {
|
||||
/// The last turn's tokens (`session/prompt` result `usage`).
|
||||
#[serde(default)]
|
||||
pub tokens: Option<AgentTokens>,
|
||||
/// How many times the agent compressed the conversation (Hermes `compressionDepth`).
|
||||
#[serde(default)]
|
||||
pub compressions: u32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentTokens {
|
||||
pub input: u32,
|
||||
pub cached: u32,
|
||||
pub output: u32,
|
||||
}
|
||||
|
||||
/// A task the agent runs in the background while the conversation goes on.
|
||||
@@ -252,6 +277,24 @@ pub struct AgentUsage {
|
||||
pub cost: Option<Box<AgentCost>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentContextUsage {
|
||||
pub categories: Vec<AgentContextCategory>,
|
||||
pub total_tokens: u32,
|
||||
pub max_tokens: u32,
|
||||
pub model: String,
|
||||
pub is_auto_compact_enabled: Option<bool>,
|
||||
pub auto_compact_threshold: Option<u32>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
pub struct AgentContextCategory {
|
||||
pub name: String,
|
||||
pub tokens: u32,
|
||||
pub kind: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentCost {
|
||||
@@ -479,6 +522,9 @@ pub enum AgentEntry {
|
||||
},
|
||||
Thought {
|
||||
text: String,
|
||||
/// When the reasoning started (ms since the epoch); `None` in tasks saved before.
|
||||
#[serde(default)]
|
||||
started_ms: Option<f64>,
|
||||
},
|
||||
Tool {
|
||||
id: String,
|
||||
@@ -490,6 +536,11 @@ pub enum AgentEntry {
|
||||
/// Text the tool reported (command output…), truncated.
|
||||
output: Option<String>,
|
||||
diffs: Vec<AgentToolDiff>,
|
||||
/// When the call started and ended (ms since the epoch); `None` in tasks saved before.
|
||||
#[serde(default)]
|
||||
started_ms: Option<f64>,
|
||||
#[serde(default)]
|
||||
ended_ms: Option<f64>,
|
||||
},
|
||||
Plan {
|
||||
items: Vec<AgentPlanItem>,
|
||||
@@ -563,6 +614,9 @@ pub struct AgentProvider {
|
||||
pub command_read_only_reason: Option<AgentCommandReadOnlyReason>,
|
||||
/// Whether the command was found (on `PATH`).
|
||||
pub installed: bool,
|
||||
/// The built-in command can be owned by a global npm package.
|
||||
#[serde(default)]
|
||||
pub can_check_cli_update: bool,
|
||||
/// Environment variables it starts with (from its agent file).
|
||||
pub env: BTreeMap<String, String>,
|
||||
/// Settings (models, modes…) the agent offered last time it ran; empty before its first session.
|
||||
|
||||
@@ -407,7 +407,7 @@ impl Shim {
|
||||
"promptCapabilities": { "image": true, "embeddedContext": true },
|
||||
"sessionCapabilities": { "fork": {} },
|
||||
"mcpCapabilities": { "stdio": true, "http": true, "sse": true },
|
||||
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true } },
|
||||
"_meta": { "openidea": { "rollback": true, "steer": true, "backgroundTasks": true, "contextUsage": true } },
|
||||
},
|
||||
"agentInfo": { "name": "claude", "title": "Claude Code", "version": self.version() },
|
||||
"authMethods": [],
|
||||
@@ -492,6 +492,11 @@ impl Shim {
|
||||
session.steer(params.get("prompt").cloned().unwrap_or_default()).map_err(invalid)?;
|
||||
Ok(json!({}))
|
||||
}
|
||||
"_openidea/context_usage" => {
|
||||
let session = self.session(¶ms)?;
|
||||
let proc = session.st.lock().proc.clone().ok_or_else(|| internal("Claude Code is not running"))?;
|
||||
rt.block_on(proc.control(json!({ "subtype": "get_context_usage" }))).map_err(internal)
|
||||
}
|
||||
"_openidea/stop_task" => {
|
||||
let session = self.session(¶ms)?;
|
||||
let task = params.get("taskId").and_then(Value::as_str).ok_or_else(|| invalid("no taskId"))?;
|
||||
|
||||
@@ -144,7 +144,8 @@ async fn discover_once(spec: ProviderSpec, cwd: PathBuf, strip_ambient: bool) ->
|
||||
move || spec.resolve_for_launch_with_copilot_env(&cwd, strip_ambient)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?;
|
||||
.map_err(|e| DiscoverError { message: e.to_string(), allow_acp_fallback: false })?
|
||||
.map_err(|e| DiscoverError { message: e, allow_acp_fallback: false })?;
|
||||
let cwd = dunce::canonicalize(&cwd).unwrap_or(cwd);
|
||||
let args = headless_args(&launch.args);
|
||||
let peer = Peer::spawn_framed(
|
||||
|
||||
@@ -312,7 +312,7 @@ impl Settings {
|
||||
}
|
||||
|
||||
/// Parses `models.list` + optional `models.listTokenPriceUnits` into catalog entries,
|
||||
/// prepending `"auto"` when not already in the list.
|
||||
/// prepending `"auto"` when direct models are present or Copilot advertises an enabled Auto tier.
|
||||
pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<ModelEntry> {
|
||||
let units = parse_price_units(price_units);
|
||||
let raw = list
|
||||
@@ -322,7 +322,7 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
|
||||
.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() {
|
||||
if !raw.iter().any(|m| str_of(m, "id") == Some("auto")) && (!raw.is_empty() || auto_model_available(list)) {
|
||||
out.push(ModelEntry {
|
||||
id: "auto".into(),
|
||||
name: "Auto".into(),
|
||||
@@ -344,6 +344,18 @@ pub(super) fn parse_catalog(list: &Value, price_units: Option<&Value>) -> Vec<Mo
|
||||
out
|
||||
}
|
||||
|
||||
fn auto_model_available(list: &Value) -> bool {
|
||||
let Some(auto) = list.get("auto") else { return false };
|
||||
if auto.get("enabled").or_else(|| auto.pointer("/status/enabled")).and_then(Value::as_bool) == Some(false) {
|
||||
return false;
|
||||
}
|
||||
let Some(tiers) = auto.get("tiers").and_then(Value::as_array) else { return auto.is_object() };
|
||||
tiers.is_empty()
|
||||
|| tiers.iter().any(|tier| {
|
||||
tier.get("enabled").or_else(|| tier.pointer("/status/enabled")).and_then(Value::as_bool) != Some(false)
|
||||
})
|
||||
}
|
||||
|
||||
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)
|
||||
|
||||
@@ -110,6 +110,72 @@ fn sample_price_units() -> Value {
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_an_enabled_auto_only_catalog() {
|
||||
let list = json!({
|
||||
"models": [],
|
||||
"auto": {
|
||||
"defaultTier": "balance",
|
||||
"tiers": [
|
||||
{
|
||||
"id": "balance",
|
||||
"displayName": "Standard",
|
||||
"type": "auto",
|
||||
"fusionTier": "standard",
|
||||
"status": { "enabled": true, "pickerVisible": true }
|
||||
},
|
||||
{
|
||||
"id": "hydrafusion",
|
||||
"displayName": "High",
|
||||
"type": "fusion",
|
||||
"fusionTier": "high",
|
||||
"status": {
|
||||
"enabled": false,
|
||||
"pickerVisible": true,
|
||||
"reason": "user_not_eligible"
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "fast",
|
||||
"displayName": "Fast",
|
||||
"type": "auto",
|
||||
"status": { "enabled": true, "pickerVisible": false }
|
||||
}
|
||||
],
|
||||
"providerId": "copilot"
|
||||
},
|
||||
"imageModels": []
|
||||
});
|
||||
|
||||
let catalog = models::parse_catalog(&list, None);
|
||||
assert_eq!(catalog.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(), ["auto"]);
|
||||
assert_eq!(Settings::new(&catalog, &UserDefaults::default()).model, "auto");
|
||||
|
||||
let options =
|
||||
config::parse_options(&models::config_options(&catalog, &Settings::new(&catalog, &UserDefaults::default())));
|
||||
let model = options.iter().find(|option| option.id == MODEL).unwrap();
|
||||
assert_eq!(model.current.as_deref(), Some("auto"));
|
||||
assert_eq!(model.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["auto"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_an_auto_only_catalog_when_every_tier_is_disabled() {
|
||||
let list = json!({
|
||||
"models": [],
|
||||
"auto": {
|
||||
"defaultTier": "balance",
|
||||
"tiers": [
|
||||
{
|
||||
"id": "balance",
|
||||
"status": { "enabled": false, "pickerVisible": true }
|
||||
}
|
||||
]
|
||||
}
|
||||
});
|
||||
|
||||
assert!(models::parse_catalog(&list, None).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_tiered_context_windows_pricing_and_uses_copilots_own_defaults() {
|
||||
let catalog = models::parse_catalog(&sample_models_list(), Some(&sample_price_units()));
|
||||
|
||||
@@ -9,6 +9,8 @@ use serde_json::Value;
|
||||
use std::collections::BTreeMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub(crate) const COPILOT_GITHUB_ACCOUNT_ENV: &str = "OPENIDEA_COPILOT_GITHUB_ACCOUNT";
|
||||
|
||||
/// The protocol an agent speaks. Native ones run behind an in-process ACP endpoint
|
||||
/// (`native`), so tasks see every agent as ACP and read features from its capabilities.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
@@ -82,6 +84,7 @@ const BUILTIN: &[(&str, &str, Driver, &[&str], &str)] = &[
|
||||
("kiro", "Kiro", Driver::Acp, &["kiro-cli", "acp"], "Run `kiro-cli login` in a terminal."),
|
||||
("vibe", "Mistral Vibe", Driver::Acp, &["vibe-acp"], "Run `vibe` in a terminal and sign in."),
|
||||
("omp", "OMP", Driver::Acp, &["omp", "acp"], "Run `omp` in a terminal and sign in."),
|
||||
("hermes", "Hermes Agent", Driver::Acp, &["hermes", "acp"], "Run `hermes model` in a terminal."),
|
||||
];
|
||||
|
||||
fn builtins() -> Vec<ProviderSpec> {
|
||||
@@ -137,15 +140,31 @@ impl ProviderSpec {
|
||||
/// Resolve once before connecting, so authentication guidance names that same install.
|
||||
pub(crate) fn resolve_for_launch(self, cwd: &Path) -> Self {
|
||||
let strip = prefer_stored_copilot_auth();
|
||||
self.resolve_for_launch_with_copilot_env(cwd, strip)
|
||||
self.resolve_for_launch_base(cwd, strip)
|
||||
}
|
||||
|
||||
pub(crate) fn resolve_for_launch_with_copilot_env(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
|
||||
pub(crate) fn resolve_for_launch_with_copilot_env(
|
||||
self,
|
||||
cwd: &Path,
|
||||
strip_ambient_tokens: bool,
|
||||
) -> Result<Self, String> {
|
||||
let account = is_copilot_provider(&self.id).then(|| copilot_github_account(&self.env)).flatten();
|
||||
let mut resolved = self.resolve_for_launch_base(cwd, strip_ambient_tokens || account.is_some());
|
||||
if let Some(account) = account {
|
||||
let token = github_token_for_account(&account)?;
|
||||
resolved.env.retain(|(name, _)| !AMBIENT_COPILOT_AUTH_VARS.contains(&name.as_str()));
|
||||
resolved.env.push(("COPILOT_GITHUB_TOKEN".into(), token));
|
||||
}
|
||||
Ok(resolved)
|
||||
}
|
||||
|
||||
fn resolve_for_launch_base(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
|
||||
if self.driver != Driver::Acp {
|
||||
self.command = crate::native::newest_install(&self.command);
|
||||
}
|
||||
if is_copilot_provider(&self.id) {
|
||||
self.env = sanitized_copilot_env(&self.env, strip_ambient_tokens);
|
||||
self.env.retain(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
}
|
||||
let program = ide_jsonrpc::resolve_spawn_program(&self.command, &self.env);
|
||||
self.command =
|
||||
@@ -163,6 +182,50 @@ pub(crate) fn is_copilot_provider(id: &str) -> bool {
|
||||
id == "copilot" || id.starts_with("copilot-")
|
||||
}
|
||||
|
||||
pub(crate) fn copilot_github_account(env: &[(String, String)]) -> Option<String> {
|
||||
env.iter()
|
||||
.rev()
|
||||
.find(|(name, _)| name == COPILOT_GITHUB_ACCOUNT_ENV)
|
||||
.map(|(_, value)| value.trim())
|
||||
.filter(|value| !value.is_empty())
|
||||
.map(str::to_owned)
|
||||
}
|
||||
|
||||
fn github_token_for_account(account: &str) -> Result<String, String> {
|
||||
let path = ide_core::process::shell_env()
|
||||
.find(|(name, _)| name == "PATH")
|
||||
.map(|(_, value)| value)
|
||||
.or_else(|| ide_core::process::host_var_os("PATH"));
|
||||
let program = path
|
||||
.as_deref()
|
||||
.and_then(|path| ide_core::process::find_executable("gh", path))
|
||||
.ok_or_else(|| "GitHub CLI (`gh`) is required to select a Copilot GitHub account".to_owned())?;
|
||||
let mut command = std::process::Command::new(program);
|
||||
command.args(["auth", "token", "--hostname", "github.com", "--user", account]).envs(ide_core::process::shell_env());
|
||||
for name in AMBIENT_COPILOT_AUTH_VARS {
|
||||
command.env_remove(name);
|
||||
}
|
||||
let output = command
|
||||
.output()
|
||||
.map_err(|error| format!("Couldn't read GitHub authentication for account {account}: {error}"))?;
|
||||
if !output.status.success() {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
let detail = stderr.trim();
|
||||
return Err(if detail.is_empty() {
|
||||
format!("GitHub CLI has no authenticated account named {account}")
|
||||
} else {
|
||||
format!("Couldn't use GitHub account {account}: {detail}")
|
||||
});
|
||||
}
|
||||
let token = String::from_utf8(output.stdout)
|
||||
.map_err(|_| format!("GitHub CLI returned a non-text token for account {account}"))?;
|
||||
let token = token.trim();
|
||||
if token.is_empty() {
|
||||
return Err(format!("GitHub CLI returned no token for account {account}"));
|
||||
}
|
||||
Ok(token.to_owned())
|
||||
}
|
||||
|
||||
pub(crate) fn prefer_stored_copilot_auth() -> bool {
|
||||
PREFER_STORED_COPILOT_AUTH.load(std::sync::atomic::Ordering::Acquire)
|
||||
}
|
||||
@@ -310,6 +373,7 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
|
||||
command_editable: reason.is_none(),
|
||||
command_read_only_reason: reason,
|
||||
installed: installed(&spec.command),
|
||||
can_check_cli_update: spec.source == AgentSource::Builtin && crate::cli_update::package(&spec.id).is_some(),
|
||||
env: spec.env.iter().cloned().collect(),
|
||||
config: vec![],
|
||||
thought_levels: BTreeMap::new(),
|
||||
@@ -338,6 +402,31 @@ pub(crate) fn set_builtin_env(
|
||||
id: &str,
|
||||
env: BTreeMap<String, String>,
|
||||
) -> IdeResult<()> {
|
||||
if id == "copilot" {
|
||||
let file = custom_dir.join("copilot.toml");
|
||||
if file.try_exists()?
|
||||
&& let mut agent = CustomAgent::read_with(&file, id, secrets).map_err(IdeError::invalid)?
|
||||
&& agent.registry.is_some()
|
||||
{
|
||||
let existing = agent.env.clone();
|
||||
let mut existing_launch_env = existing.clone();
|
||||
let mut next_launch_env = env.clone();
|
||||
existing_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
next_launch_env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
if existing_launch_env != next_launch_env {
|
||||
return Err(IdeError::invalid(format!("{id} is installed from the ACP Registry")));
|
||||
}
|
||||
match env.get(COPILOT_GITHUB_ACCOUNT_ENV).filter(|value| !value.trim().is_empty()) {
|
||||
Some(account) => {
|
||||
agent.env.insert(COPILOT_GITHUB_ACCOUNT_ENV.into(), account.trim().into());
|
||||
}
|
||||
None => {
|
||||
agent.env.remove(COPILOT_GITHUB_ACCOUNT_ENV);
|
||||
}
|
||||
}
|
||||
return agent.write(&file).map_err(Into::into);
|
||||
}
|
||||
}
|
||||
update_builtin(custom_dir, secrets, id, |agent, _| agent.env = env)
|
||||
}
|
||||
|
||||
@@ -503,7 +592,7 @@ fn validated_custom_id(id: &str) -> IdeResult<String> {
|
||||
}
|
||||
|
||||
/// Turns an `acp.json` server name into a file-stem id (`"My Agent!"` → `"my-agent"`).
|
||||
fn slugify_id(name: &str) -> String {
|
||||
pub(crate) fn slugify_id(name: &str) -> String {
|
||||
let mut id = String::with_capacity(name.len());
|
||||
for c in name.chars() {
|
||||
if c.is_ascii_alphanumeric() {
|
||||
@@ -716,6 +805,15 @@ mod tests {
|
||||
use super::*;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn hermes_is_built_in_over_acp() {
|
||||
let spec = builtin_spec("hermes").unwrap();
|
||||
assert_eq!(spec.driver, Driver::Acp);
|
||||
let info = describe(&spec);
|
||||
assert_eq!((info.name.as_str(), info.command.as_str()), ("Hermes Agent", "hermes acp"));
|
||||
assert_eq!(info.login_hint.as_deref(), Some("Run `hermes model` in a terminal."));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn qoder_global_and_cn_editions_are_both_built_in() {
|
||||
let info = |id: &str| describe(&load(None, None).into_iter().find(|s| s.id == id).unwrap());
|
||||
@@ -945,6 +1043,46 @@ mod tests {
|
||||
set_builtin_env(dir.path(), None, "not-a-builtin", env).unwrap_err();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registry_copilot_allows_only_the_github_account_override() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("copilot.toml");
|
||||
CustomAgent {
|
||||
name: Some("GitHub Copilot".into()),
|
||||
driver: Driver::Acp,
|
||||
command: "/tools/copilot".into(),
|
||||
args: vec!["--acp".into()],
|
||||
env: BTreeMap::from([("REGISTRY_SETTING".into(), "kept".into())]),
|
||||
registry: Some(RegistryRef { id: "copilot".into(), version: "1.0.0".into() }),
|
||||
}
|
||||
.write(&file)
|
||||
.unwrap();
|
||||
|
||||
set_builtin_env(
|
||||
dir.path(),
|
||||
None,
|
||||
"copilot",
|
||||
BTreeMap::from([
|
||||
("REGISTRY_SETTING".into(), "kept".into()),
|
||||
(COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()),
|
||||
]),
|
||||
)
|
||||
.unwrap();
|
||||
let spec = load(Some(dir.path()), None).into_iter().find(|spec| spec.id == "copilot").unwrap();
|
||||
assert_eq!(copilot_github_account(&spec.env).as_deref(), Some("dengliu_microsoft"));
|
||||
|
||||
set_builtin_env(dir.path(), None, "copilot", BTreeMap::from([("REGISTRY_SETTING".into(), "changed".into())]))
|
||||
.unwrap_err();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn launch_metadata_never_passes_the_github_account_control_to_copilot() {
|
||||
let mut spec = builtin_spec("copilot").unwrap();
|
||||
spec.env.push((COPILOT_GITHUB_ACCOUNT_ENV.into(), "dengliu_microsoft".into()));
|
||||
let resolved = spec.resolve_for_launch(Path::new("."));
|
||||
assert!(resolved.env.iter().all(|(name, _)| name != COPILOT_GITHUB_ACCOUNT_ENV));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn acp_adapters_of_native_agents_are_unlisted_until_customized() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -537,6 +537,14 @@ fn install_entry_with(
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
let github_account = (entry.id == "copilot")
|
||||
.then(|| CustomAgent::read(&file).ok())
|
||||
.flatten()
|
||||
.and_then(|agent| agent.env.get(provider::COPILOT_GITHUB_ACCOUNT_ENV).cloned());
|
||||
let mut env = env;
|
||||
if let Some(account) = github_account {
|
||||
env.insert(provider::COPILOT_GITHUB_ACCOUNT_ENV.into(), account);
|
||||
}
|
||||
let agent = CustomAgent {
|
||||
name: Some(entry.name.clone()),
|
||||
driver: Driver::Acp,
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
//! Claude Code's slash commands on disk, for completion before (or without) a session:
|
||||
//! skills (`.claude/skills/<dir>/SKILL.md`) and custom commands (`.claude/commands/**/*.md`)
|
||||
//! of the working directory and every directory above it, then the user's `~/.claude`.
|
||||
//! of the working directory and every directory above it, then the user's `~/.claude`; and
|
||||
//! the skills of a Hermes profile (`<profile>/skills`).
|
||||
|
||||
use crate::{AgentCommand, AgentCommandSource};
|
||||
use std::collections::HashSet;
|
||||
@@ -34,6 +35,19 @@ pub(crate) fn discover(cwd: &Path, home: Option<&Path>) -> Vec<AgentCommand> {
|
||||
out
|
||||
}
|
||||
|
||||
/// The skills of a Hermes profile: `<profile>/skills/<skill>` and `<profile>/skills/<category>/<skill>`;
|
||||
/// the first of a name wins.
|
||||
pub(crate) fn hermes(profile: &Path) -> Vec<AgentCommand> {
|
||||
let root = profile.join("skills");
|
||||
let mut found = skills(&root);
|
||||
for category in sorted(&root).into_iter().filter(|p| !p.join("SKILL.md").exists()) {
|
||||
found.extend(skills(&category));
|
||||
}
|
||||
let mut seen = HashSet::new();
|
||||
found.retain(|c| seen.insert(c.name.clone()));
|
||||
found
|
||||
}
|
||||
|
||||
/// `first` (the agent's own list) plus the commands of `more` it lacks.
|
||||
pub(crate) fn merge(first: Vec<AgentCommand>, more: Vec<AgentCommand>) -> Vec<AgentCommand> {
|
||||
let mut out = first;
|
||||
@@ -256,6 +270,24 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hermes_skills_flat_and_in_categories() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let profile = tmp.path();
|
||||
assert!(hermes(profile).is_empty());
|
||||
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan", "skills/empty"] {
|
||||
std::fs::create_dir_all(profile.join(dir)).unwrap();
|
||||
}
|
||||
for dir in ["skills/plan", "skills/dev/review", "skills/dev/plan"] {
|
||||
std::fs::write(profile.join(dir).join("SKILL.md"), "---\ndescription: d\n---\n").unwrap();
|
||||
}
|
||||
let names: Vec<_> = hermes(profile).into_iter().map(|c| (c.name, c.source)).collect();
|
||||
assert_eq!(
|
||||
names,
|
||||
[("plan".to_owned(), AgentCommandSource::Skill), ("review".to_owned(), AgentCommandSource::Skill)]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nothing_without_claude_dirs() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -452,6 +452,35 @@ fn manager(dir: &Path, agent: Arc<FakeAgent>) -> AgentManager {
|
||||
manager_at(dir, &dir.join("models.json"), agent)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn subscribers_do_not_replace_or_close_each_other() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let main = Arc::new(Mutex::new(Vec::new()));
|
||||
let child = Arc::new(Mutex::new(Vec::new()));
|
||||
let subscribe = |window: &str, events: &Arc<Mutex<Vec<AgentEvent>>>| {
|
||||
let events = events.clone();
|
||||
mgr.subscribe_as(window, Arc::new(move |event| events.lock().push(event)));
|
||||
};
|
||||
subscribe("main", &main);
|
||||
subscribe("editor-main-1", &child);
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 1);
|
||||
assert_eq!(child.lock().len(), 1);
|
||||
// A reloaded webview replaces only its own old channel.
|
||||
let reloaded = Arc::new(Mutex::new(Vec::new()));
|
||||
subscribe("editor-main-1", &reloaded);
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 2);
|
||||
assert_eq!(child.lock().len(), 1);
|
||||
assert_eq!(reloaded.lock().len(), 1);
|
||||
mgr.unsubscribe("editor-main-1");
|
||||
mgr.shared.emit(AgentEvent::Providers);
|
||||
assert_eq!(main.lock().len(), 3);
|
||||
assert_eq!(reloaded.lock().len(), 1);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentManager {
|
||||
// These tests speak to FakeAgent, never an installed CLI, including after a provider reload.
|
||||
let agents = dir.join("agents");
|
||||
@@ -909,6 +938,27 @@ async fn authenticates_and_retries_session_setup_once_on_auth_error() {
|
||||
mgr3.shutdown();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn hermes_profiles_complete_their_own_skills() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let skill = |dir: &str, name: &str| {
|
||||
let dir = tmp.path().join(dir).join(name);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::fs::write(dir.join("SKILL.md"), format!("---\nname: {name}\ndescription: d\n---\n")).unwrap();
|
||||
};
|
||||
skill(".hermes/skills", "plan");
|
||||
skill(".hermes/profiles/dom/skills/home", "lights");
|
||||
std::fs::write(tmp.path().join(".hermes/profiles/dom/config.yaml"), "").unwrap();
|
||||
let mgr = manager_at(tmp.path(), &tmp.path().join("models.json"), Arc::new(FakeAgent::default()));
|
||||
let names = |c: Vec<AgentCommand>| c.into_iter().map(|c| c.name).collect::<Vec<_>>();
|
||||
assert!(names(mgr.commands("hermes", None).await.unwrap()).contains(&"plan".to_owned()));
|
||||
let dom = names(mgr.commands("hermes-dom", None).await.unwrap());
|
||||
assert!(dom.contains(&"lights".to_owned()) && !dom.contains(&"plan".to_owned()));
|
||||
assert!(!names(mgr.commands("claude", None).await.unwrap()).contains(&"plan".to_owned()));
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn commands_are_remembered_per_project_and_merged_with_skills_on_disk() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1877,6 +1927,32 @@ async fn real_claude_task_in_a_worktree() {
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn hermes_session_info_names_the_task_and_counts_compressions() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
// "again" ends the turn at once; the default prompt waits for a permission answer.
|
||||
.create(NewAgentTask { prompt: text("again"), provider: "claude".into(), ..Default::default() })
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let handle = mgr.task(&task.id).unwrap();
|
||||
let info = |title: &str, depth: u32| {
|
||||
json!({"sessionUpdate": "session_info_update", "title": title, "updatedAt": "2026-11-18T18:35:32.068362+00:00",
|
||||
"_meta": {"hermes": {"sessionProvenance": {"sessionKind": "root", "parentHermesSessionId": null,
|
||||
"compressionDepth": depth}}}})
|
||||
};
|
||||
handle.on_update(None, &info("Make a 3-step plan and carry it out: 1) list the…", 0));
|
||||
handle.on_update(None, &info("List files and edit notes.txt", 0));
|
||||
let t = handle.state.lock().task.clone();
|
||||
assert_eq!(t.title, "List files and edit notes.txt", "the agent's latest title wins");
|
||||
assert_eq!(t.stats.compressions, 0);
|
||||
handle.on_update(None, &info("List files and edit notes.txt", 2));
|
||||
assert_eq!(handle.state.lock().task.stats.compressions, 2);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn renamed_titles_survive_updates_forks_and_restart() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -2286,6 +2362,56 @@ async fn idle_model_switches_discover_controls_and_no_control_models_without_ano
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn session_without_a_model_option_can_select_from_a_recovered_catalog() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
|
||||
let spec = mgr.shared.spec("claude-acp").unwrap();
|
||||
let (_, flight) = mgr.shared.paths.catalogs.request(&mgr.shared, spec, true, None);
|
||||
if let Some(mut ready) = flight {
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !*ready.borrow_and_update() {
|
||||
ready.changed().await.unwrap();
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
{
|
||||
let task = mgr.task(&task.id).unwrap();
|
||||
let mut state = task.state.lock();
|
||||
state.task.config.retain(|option| option.category.as_deref() != Some("model"));
|
||||
state.task.model = Some("stale-model".into());
|
||||
}
|
||||
|
||||
mgr.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
let task = mgr.task(&task.id).unwrap();
|
||||
{
|
||||
let state = task.state.lock();
|
||||
assert_eq!(state.task.model.as_deref(), Some("small"));
|
||||
let model = state.task.config.iter().find(|option| option.category.as_deref() == Some("model")).unwrap();
|
||||
assert_eq!(model.current.as_deref(), Some("small"));
|
||||
assert!(model.values.iter().any(|value| value.value == "small"));
|
||||
}
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -3531,11 +3657,13 @@ fn streamed_text_is_sent_as_appends() {
|
||||
);
|
||||
let replaced = entry_event("t", &mut streamed, None, 3, &agent("Other"));
|
||||
assert!(matches!(replaced, AgentEvent::Entry { .. }), "text that doesn't extend the sent text is sent whole");
|
||||
let thought = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm…".into() });
|
||||
let thought = AgentEntry::Thought { text: "hmm…".into(), started_ms: None };
|
||||
let thought = entry_event("t", &mut streamed, None, 4, &thought);
|
||||
assert!(matches!(thought, AgentEvent::Entry { index: 4, .. }), "a new message starts whole");
|
||||
let tool = AgentEntry::Error { message: "x".into() };
|
||||
entry_event("t", &mut streamed, None, 4, &tool);
|
||||
let again = entry_event("t", &mut streamed, None, 4, &AgentEntry::Thought { text: "hmm… ok".into() });
|
||||
let again = AgentEntry::Thought { text: "hmm… ok".into(), started_ms: None };
|
||||
let again = entry_event("t", &mut streamed, None, 4, &again);
|
||||
assert!(matches!(again, AgentEvent::Entry { .. }), "an entry replaced by another kind forgets its text");
|
||||
|
||||
let long = "é".repeat(5000);
|
||||
|
||||
@@ -85,6 +85,8 @@ impl Timeline {
|
||||
locations: locations(update.get("locations")),
|
||||
output: None,
|
||||
diffs: Vec::new(),
|
||||
started_ms: Some(crate::now_ms()),
|
||||
ended_ms: None,
|
||||
};
|
||||
let index = match self.tools.get(&id) {
|
||||
Some(&i) => {
|
||||
@@ -134,17 +136,22 @@ impl Timeline {
|
||||
fn append_text(&mut self, thought: bool, text: &str) -> usize {
|
||||
match self.entries.last_mut() {
|
||||
Some(AgentEntry::Agent { text: t }) if !thought => t.push_str(text),
|
||||
Some(AgentEntry::Thought { text: t }) if thought => t.push_str(text),
|
||||
Some(AgentEntry::Thought { text: t, .. }) if thought => t.push_str(text),
|
||||
_ => {
|
||||
let text = text.to_owned();
|
||||
return self.push(if thought { AgentEntry::Thought { text } } else { AgentEntry::Agent { text } });
|
||||
return self.push(if thought {
|
||||
AgentEntry::Thought { text, started_ms: Some(crate::now_ms()) }
|
||||
} else {
|
||||
AgentEntry::Agent { text }
|
||||
});
|
||||
}
|
||||
}
|
||||
self.entries.len() - 1
|
||||
}
|
||||
|
||||
fn merge_tool(&mut self, index: usize, update: &Value) {
|
||||
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, .. } = &mut self.entries[index]
|
||||
let AgentEntry::Tool { title, kind, status, locations: locs, output, diffs, ended_ms, .. } =
|
||||
&mut self.entries[index]
|
||||
else {
|
||||
return;
|
||||
};
|
||||
@@ -156,6 +163,9 @@ impl Timeline {
|
||||
}
|
||||
if let Some(s) = tool_status(update.get("status")) {
|
||||
*status = s;
|
||||
if matches!(s, AgentToolStatus::Completed | AgentToolStatus::Failed) && ended_ms.is_none() {
|
||||
*ended_ms = Some(crate::now_ms());
|
||||
}
|
||||
}
|
||||
if update.get("locations").is_some_and(Value::is_array) {
|
||||
*locs = locations(update.get("locations"));
|
||||
@@ -183,6 +193,11 @@ impl Timeline {
|
||||
}
|
||||
}
|
||||
if !text.is_empty() {
|
||||
// The command a call announced (`$ cmd`) stays above the result that replaces it.
|
||||
let command = output.as_deref().and_then(|o| o.lines().next()).filter(|l| l.starts_with("$ "));
|
||||
if let Some(command) = command.filter(|c| !text.starts_with(c)) {
|
||||
text = format!("{command}\n{text}");
|
||||
}
|
||||
*output = Some(tail(text));
|
||||
}
|
||||
if !new_diffs.is_empty() {
|
||||
@@ -432,11 +447,14 @@ mod tests {
|
||||
assert_eq!(t.apply(&chunk("lo")).changed, vec![0]);
|
||||
t.apply(&json!({"sessionUpdate": "agent_thought_chunk", "content": {"type": "text", "text": "hmm"}}));
|
||||
t.apply(&chunk("again"));
|
||||
// The thought's start is the clock's: it is there, and the rest compares exactly.
|
||||
let AgentEntry::Thought { started_ms, .. } = &mut t.entries[1] else { panic!("{:?}", t.entries) };
|
||||
assert!(started_ms.take().is_some());
|
||||
assert_eq!(
|
||||
t.entries,
|
||||
vec![
|
||||
AgentEntry::Agent { text: "Hello".into() },
|
||||
AgentEntry::Thought { text: "hmm".into() },
|
||||
AgentEntry::Thought { text: "hmm".into(), started_ms: None },
|
||||
AgentEntry::Agent { text: "again".into() },
|
||||
]
|
||||
);
|
||||
@@ -528,6 +546,25 @@ mod tests {
|
||||
assert!(matches!(t.entries[2], AgentEntry::User { done_ms: None, .. }));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_hermes_terminal_call_keeps_its_command_and_times() {
|
||||
let text = |t: &str| serde_json::json!([{"type": "content", "content": {"type": "text", "text": t}}]);
|
||||
let mut t = Timeline::default();
|
||||
t.apply(&serde_json::json!({"sessionUpdate": "tool_call", "toolCallId": "tc-0b98b5e30a28",
|
||||
"kind": "execute", "title": "terminal: echo ok + 2 commands", "locations": [],
|
||||
"content": text("$ echo ok >> notes.txt && wc -l notes.txt")}));
|
||||
let AgentEntry::Tool { started_ms, ended_ms, .. } = &t.entries[0] else { panic!() };
|
||||
assert!(started_ms.is_some() && ended_ms.is_none());
|
||||
t.apply(&serde_json::json!({"sessionUpdate": "tool_call_update", "toolCallId": "tc-0b98b5e30a28",
|
||||
"kind": "execute", "status": "completed",
|
||||
"content": text("terminal result\n- **output:** 3 notes.txt\n- **exit_code:** 0")}));
|
||||
let AgentEntry::Tool { output, status, ended_ms, .. } = &t.entries[0] else { panic!() };
|
||||
assert_eq!(*status, AgentToolStatus::Completed);
|
||||
assert!(ended_ms.is_some());
|
||||
let expected = "$ echo ok >> notes.txt && wc -l notes.txt\nterminal result\n- **output:** 3 notes.txt\n";
|
||||
assert_eq!(output.as_deref(), Some(format!("{expected}- **exit_code:** 0").as_str()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn long_output_keeps_its_tail() {
|
||||
let s = tail("é".repeat(MAX_OUTPUT));
|
||||
|
||||
@@ -236,10 +236,9 @@ fn classpath(
|
||||
}
|
||||
args.extend(["dependency:build-classpath", output_arg.as_str(), scope_arg.as_str(), "-q"]);
|
||||
let top_dir = subdir(root, &target.top.dir);
|
||||
let status = ProcCommand::new(&target.top.command)
|
||||
.args(&args)
|
||||
.envs(&target.top.env)
|
||||
.current_dir(&top_dir)
|
||||
let mut command = ProcCommand::new(&target.top.command);
|
||||
command.args(&args).envs(&target.top.env).current_dir(&top_dir);
|
||||
let status = ide_core::process::prepare(&mut command)
|
||||
.output()
|
||||
.map_err(|e| IdeError::internal(format!("cannot resolve the compile classpath: {e}")))?;
|
||||
if !status.status.success() {
|
||||
|
||||
@@ -82,11 +82,23 @@ pub fn load_linked(
|
||||
maven_repo: Option<PathBuf>,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
gradle_settings: &ide_core::settings::GradleSettings,
|
||||
) -> BuildModel {
|
||||
load_linked_with_jdk(root, cache_dir, maven_repo, settings, gradle_settings, None)
|
||||
}
|
||||
|
||||
/// [`load_linked`] with the JDK Maven runs on, for JDK-activated Maven profiles.
|
||||
pub fn load_linked_with_jdk(
|
||||
root: &Path,
|
||||
cache_dir: &Path,
|
||||
maven_repo: Option<PathBuf>,
|
||||
settings: &ide_core::settings::MavenSettings,
|
||||
gradle_settings: &ide_core::settings::GradleSettings,
|
||||
maven_jdk_version: Option<u32>,
|
||||
) -> BuildModel {
|
||||
let maven = maven::has_projects(root, settings).then(|| {
|
||||
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
|
||||
let repo = maven_repo.or_else(maven::default_local_repo);
|
||||
let mut m = maven::load_with_linked(root, repo, &profiles, &settings.linked_projects);
|
||||
let mut m = maven::load_with_linked_jdk(root, repo, &profiles, maven_jdk_version, &settings.linked_projects);
|
||||
maven::UnlinkedProjects::from_model(&m, settings).filter(&mut m);
|
||||
// The user settings' profiles can be chosen too (`-P` applies to them as well).
|
||||
for p in maven::user_settings_file(root, settings).map(|f| maven::settings_profiles(&f)).unwrap_or_default() {
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -197,6 +197,7 @@ pub enum ImportsOnPaste {
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct FoldingSettings {
|
||||
pub show_outline: bool,
|
||||
pub outline_visibility: FoldingOutlineVisibility,
|
||||
pub file_header: bool,
|
||||
pub imports: bool,
|
||||
pub doc_comments: bool,
|
||||
@@ -204,10 +205,24 @@ pub struct FoldingSettings {
|
||||
|
||||
impl Default for FoldingSettings {
|
||||
fn default() -> Self {
|
||||
Self { show_outline: true, file_header: true, imports: true, doc_comments: false }
|
||||
Self {
|
||||
show_outline: true,
|
||||
outline_visibility: FoldingOutlineVisibility::Hover,
|
||||
file_header: true,
|
||||
imports: true,
|
||||
doc_comments: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum FoldingOutlineVisibility {
|
||||
#[default]
|
||||
Hover,
|
||||
Always,
|
||||
}
|
||||
|
||||
/// Editor › General › Editor Tabs.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
@@ -543,3 +558,24 @@ mod auto_import_tests {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod folding_tests {
|
||||
use super::{FoldingOutlineVisibility, FoldingSettings};
|
||||
|
||||
#[test]
|
||||
fn folding_outline_defaults_to_hover_for_existing_settings() {
|
||||
let settings: FoldingSettings = serde_json::from_str(r#"{"showOutline":false}"#).unwrap();
|
||||
assert!(!settings.show_outline);
|
||||
assert_eq!(settings.outline_visibility, FoldingOutlineVisibility::Hover);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn folding_outline_visibility_round_trips() {
|
||||
for mode in ["hover", "always"] {
|
||||
let json = serde_json::json!({ "outlineVisibility": mode });
|
||||
let settings: FoldingSettings = serde_json::from_value(json).unwrap();
|
||||
assert_eq!(serde_json::to_value(settings).unwrap()["outlineVisibility"], mode);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -89,6 +89,14 @@ pub enum IdeEvent {
|
||||
DocDirty {
|
||||
doc: DocId,
|
||||
dirty: bool,
|
||||
/// Text version when this transition occurred, including when it was saved.
|
||||
version: u32,
|
||||
},
|
||||
/// An open document's file changed on disk while the buffer had unsaved changes. The buffer
|
||||
/// keeps them (autosave leaves the file alone); the UI offers to load the disk version.
|
||||
DocDiskConflict {
|
||||
doc: DocId,
|
||||
path: String,
|
||||
},
|
||||
/// A complete workspace edit can be undone as one operation.
|
||||
WorkspaceEditApplied {
|
||||
|
||||
@@ -15,6 +15,7 @@ pub mod inspection_settings;
|
||||
pub mod ipc_path;
|
||||
pub mod java_runtime;
|
||||
pub mod jsonc;
|
||||
pub mod memory;
|
||||
pub mod output_encoding;
|
||||
pub mod platform;
|
||||
pub mod process;
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
//! Returning freed heap pages to the OS.
|
||||
|
||||
/// Hands pages the allocator has freed but kept back to the OS. Call after a burst of
|
||||
/// short-lived allocations (a full index scan); until then they still count towards the
|
||||
/// process's memory footprint.
|
||||
pub fn release_free_pages() {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
unsafe extern "C" {
|
||||
fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
|
||||
}
|
||||
// SAFETY: a null zone covers every zone; a zero goal releases as much as possible.
|
||||
unsafe { malloc_zone_pressure_relief(std::ptr::null_mut(), 0) };
|
||||
}
|
||||
#[cfg(all(target_os = "linux", target_env = "gnu"))]
|
||||
// SAFETY: malloc_trim only returns free memory to the OS.
|
||||
unsafe {
|
||||
libc::malloc_trim(0);
|
||||
}
|
||||
}
|
||||
@@ -100,16 +100,6 @@ pub struct AgentSettings {
|
||||
pub smooth_text: bool,
|
||||
/// Conversations and the composer expand to the full width of the pane instead of staying in a centred column.
|
||||
pub fit_window_width: bool,
|
||||
/// While the agent works, playful words fill the pauses in what it reports.
|
||||
pub playful_status: bool,
|
||||
/// Seconds the agent reports nothing new before the playful words take over; 0 shows them
|
||||
/// from the start.
|
||||
pub playful_after_seconds: u32,
|
||||
/// The user's playful words by activity (`working`, `thinking`, `reading`, …), replacing
|
||||
/// the built-in ones of that activity; an empty list keeps its status factual.
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = BTreeMap<String, Vec<String>>)]
|
||||
pub playful_words: BTreeMap<String, Vec<String>>,
|
||||
#[serde(deserialize_with = "or_default")]
|
||||
#[specta(type = ThinkingDisplay)]
|
||||
pub thinking: ThinkingDisplay,
|
||||
@@ -152,9 +142,6 @@ impl Default for AgentSettings {
|
||||
fold_turns: true,
|
||||
smooth_text: true,
|
||||
fit_window_width: false,
|
||||
playful_status: false,
|
||||
playful_after_seconds: 0,
|
||||
playful_words: BTreeMap::new(),
|
||||
thinking: ThinkingDisplay::Auto,
|
||||
tool_calls: ToolCallDisplay::Grouped,
|
||||
expand_tool_output: false,
|
||||
|
||||
@@ -11,6 +11,8 @@ use std::collections::BTreeMap;
|
||||
pub struct VcsSettings {
|
||||
/// Colour folders that contain changed files (project tree, tabs).
|
||||
pub show_dirty_directories: bool,
|
||||
/// Diffs the user opens show in an editor tab; off, in a separate window.
|
||||
pub diff_as_editor_tab: bool,
|
||||
/// Stop file history (Show History) after `history_limit` commits.
|
||||
pub limit_history: bool,
|
||||
pub history_limit: u32,
|
||||
@@ -55,6 +57,7 @@ impl Default for VcsSettings {
|
||||
Self {
|
||||
// IDEA's VcsConfiguration.SHOW_DIRTY_RECURSIVELY is off by default.
|
||||
show_dirty_directories: false,
|
||||
diff_as_editor_tab: true,
|
||||
limit_history: true,
|
||||
history_limit: 1000,
|
||||
git: GitSettings::default(),
|
||||
@@ -76,6 +79,8 @@ pub struct GitSettings {
|
||||
/// label is plain text and a click on it places the caret as past the line end.
|
||||
pub inline_blame_clickable: bool,
|
||||
pub show_branch_in_project_view: bool,
|
||||
/// Branch operations from the branches popup act on every repository of the project.
|
||||
pub sync_branch_operations: bool,
|
||||
/// Path to the git executable; empty = auto-detect.
|
||||
pub executable: String,
|
||||
/// Default of Update Project: `merge` | `rebase`.
|
||||
@@ -117,6 +122,7 @@ impl Default for GitSettings {
|
||||
inline_blame: false,
|
||||
inline_blame_clickable: true,
|
||||
show_branch_in_project_view: false,
|
||||
sync_branch_operations: true,
|
||||
executable: String::new(),
|
||||
update_method: "merge".into(),
|
||||
auto_update_on_push_rejected: false,
|
||||
@@ -176,6 +182,8 @@ pub struct CommitSettings {
|
||||
pub agent_model: String,
|
||||
/// That model's thinking level for commit messages; empty keeps the agent's.
|
||||
pub agent_effort: String,
|
||||
/// Show the Generate Commit Message with Agent button above the commit message.
|
||||
pub agent_button: bool,
|
||||
}
|
||||
|
||||
impl Default for CommitSettings {
|
||||
@@ -201,6 +209,7 @@ impl Default for CommitSettings {
|
||||
agent: String::new(),
|
||||
agent_model: String::new(),
|
||||
agent_effort: String::new(),
|
||||
agent_button: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -606,3 +615,16 @@ impl Default for AgentSecuritySettings {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn git_settings_without_sync_key_execute_on_all_repositories() {
|
||||
let missing: GitSettings = serde_json::from_str("{}").unwrap();
|
||||
assert!(missing.sync_branch_operations);
|
||||
let off: GitSettings = serde_json::from_str(r#"{"syncBranchOperations":false}"#).unwrap();
|
||||
assert!(!off.sync_branch_operations);
|
||||
}
|
||||
}
|
||||
@@ -145,30 +145,38 @@ impl ClickhousePool {
|
||||
let cancel = CancellationToken::new();
|
||||
let initialize = async {
|
||||
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
|
||||
if !rejects_driver_setting(&error) {
|
||||
let Some(setting) = rejected_driver_setting(&error) else {
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
if !use_http_session {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Retry only the connection probe. Keep relying on the server for write protection
|
||||
// only after verifying strict read-only mode in this same session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// Start the proof in a fresh session: the rejected probe may have left
|
||||
// its id on another replica without applying the configured database.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
if setting == "readonly" {
|
||||
return Err(error);
|
||||
}
|
||||
if !source.read_only {
|
||||
return Err(IdeError::new(
|
||||
error.kind,
|
||||
format!(
|
||||
"{}; enable Read-only for independent queries on a strict read-only server",
|
||||
error.message
|
||||
),
|
||||
));
|
||||
}
|
||||
// Every request still sends readonly=1, regardless of which node answers.
|
||||
pool.0.session.lock().await.strict_read_only = true;
|
||||
pool.execute("SELECT 1", 1, &cancel).await?;
|
||||
} else {
|
||||
// Only rely on the server's write protection after proving strict read-only
|
||||
// in this same named session.
|
||||
{
|
||||
let mut session = pool.0.session.lock().await;
|
||||
// The rejected probe may have opened a session on a different node.
|
||||
session.id = Some(uuid::Uuid::new_v4().to_string());
|
||||
session.strict_read_only = true;
|
||||
}
|
||||
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
|
||||
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
// The HTTP database parameter applies to one request. A named session needs
|
||||
@@ -236,7 +244,7 @@ impl ClickhousePool {
|
||||
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
|
||||
request = request.query(&[("database", &self.0.database)]);
|
||||
}
|
||||
if self.0.read_only && !session.strict_read_only {
|
||||
if self.0.read_only && (session.id.is_none() || !session.strict_read_only) {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
request
|
||||
@@ -324,7 +332,7 @@ impl ClickhousePool {
|
||||
result
|
||||
}
|
||||
None => {
|
||||
let killed = self.kill(&client, &query_id).await;
|
||||
let killed = self.kill(&client, &query_id, &session).await;
|
||||
match killed {
|
||||
Ok(()) => Err(IdeError::cancelled()),
|
||||
Err(error) => Err(IdeError::new(
|
||||
@@ -336,15 +344,16 @@ impl ClickhousePool {
|
||||
}
|
||||
}
|
||||
|
||||
async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
|
||||
let response = client
|
||||
async fn kill(&self, client: &Client, query_id: &str, session: &Session) -> IdeResult<()> {
|
||||
let mut request = client
|
||||
.post(self.0.endpoint.clone())
|
||||
.basic_auth(&self.0.user, Some(&self.0.password))
|
||||
.timeout(Duration::from_secs(3))
|
||||
.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
|
||||
.send()
|
||||
.await
|
||||
.map_err(http_error)?;
|
||||
.timeout(Duration::from_secs(3));
|
||||
if self.0.read_only && session.id.is_none() {
|
||||
request = request.query(&[("readonly", "1")]);
|
||||
}
|
||||
let response =
|
||||
request.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")).send().await.map_err(http_error)?;
|
||||
let status = response.status();
|
||||
let code = response
|
||||
.headers()
|
||||
@@ -551,13 +560,14 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
|
||||
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
|
||||
}
|
||||
|
||||
fn rejects_driver_setting(error: &IdeError) -> bool {
|
||||
fn rejected_driver_setting(error: &IdeError) -> Option<&str> {
|
||||
error
|
||||
.message
|
||||
.split_once(": ")
|
||||
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
|
||||
.and_then(|detail| detail.split_once("' setting in readonly mode"))
|
||||
.is_some_and(|(name, _)| {
|
||||
.map(|(name, _)| name)
|
||||
.filter(|&name| {
|
||||
matches!(
|
||||
name,
|
||||
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
|
||||
@@ -953,19 +963,77 @@ mod tests {
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
|
||||
for read_only in [false, true] {
|
||||
let (port, requests) = server(vec![(
|
||||
async fn strict_stateless_connections_keep_readonly_on_every_request() {
|
||||
let denied = "Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)";
|
||||
let (port, requests) = server(vec![
|
||||
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", denied),
|
||||
("200 OK", "", ONE),
|
||||
(
|
||||
"500 Internal Server Error",
|
||||
"X-ClickHouse-Exception-Code: 164\r\n",
|
||||
"Code: 164. DB::Exception: Cannot execute query in readonly mode. (READONLY)",
|
||||
),
|
||||
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[0]\n[1]\n[2]\n"),
|
||||
])
|
||||
.await;
|
||||
let source = DataSource {
|
||||
database: "fixture_database".into(),
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let write = "CREATE TABLE fixture_table (n UInt8) ENGINE=Memory";
|
||||
assert!(pool.execute(write, 1, &cancel).await.unwrap_err().message.contains("Code: 164"));
|
||||
let sql = "SELECT number AS n FROM numbers(3) LIMIT 3";
|
||||
let result = pool.execute(sql, 1, &cancel).await.unwrap();
|
||||
assert_eq!(result.rows, vec![vec![Some("0".into())]]);
|
||||
assert!(result.has_more);
|
||||
let requests = requests.await.unwrap();
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
assert!(requests[1].ends_with("SELECT 1"));
|
||||
assert!(requests[2].ends_with(write));
|
||||
assert!(requests[3].ends_with(sql));
|
||||
for (index, request) in requests.iter().enumerate() {
|
||||
let url = request_url(request);
|
||||
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
|
||||
assert_eq!(query_value(&url, name), None, "{name}");
|
||||
}
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
|
||||
assert_eq!(query_value(&url, "database").as_deref(), Some("fixture_database"));
|
||||
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
|
||||
assert_eq!(query_value(&url, "max_result_rows").as_deref(), (index == 0).then_some("2"));
|
||||
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), (index == 0).then_some("break"));
|
||||
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), (index == 0).then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn stateless_connections_require_readonly_and_only_relax_driver_result_settings() {
|
||||
for (read_only, detail, body) in [
|
||||
(
|
||||
false,
|
||||
"enable Read-only",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
|
||||
)])
|
||||
.await;
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'readonly'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'readonly' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
(
|
||||
true,
|
||||
"Cannot modify 'max_threads'",
|
||||
"Code: 164. DB::Exception: Cannot modify 'max_threads' setting in readonly mode. (READONLY)",
|
||||
),
|
||||
] {
|
||||
let (port, requests) =
|
||||
server(vec![("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", body)]).await;
|
||||
let source =
|
||||
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
|
||||
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
|
||||
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
|
||||
assert!(error.message.contains("use_http_session=false requires per-request"));
|
||||
assert!(error.message.contains(detail), "{}", error.message);
|
||||
let requests = requests.await.unwrap();
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert!(requests[0].ends_with("SELECT 1"));
|
||||
@@ -1041,7 +1109,7 @@ mod tests {
|
||||
let error = IdeError::invalid(format!(
|
||||
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
|
||||
));
|
||||
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
|
||||
assert_eq!(rejected_driver_setting(&error).is_some(), expected, "{setting}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1084,37 +1152,45 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancellation_sends_kill_outside_the_busy_session() {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let pool = Pool::connect(&source(port), None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
|
||||
let url = Url::parse(&format!("http://localhost{target}")).unwrap();
|
||||
let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
assert!(!kill.contains("session_id="));
|
||||
for stateless in [false, true] {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let (started, received) = tokio::sync::oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut health, _) = listener.accept().await.unwrap();
|
||||
read_request(&mut health).await;
|
||||
reply(&mut health, "200 OK", "", ONE).await;
|
||||
drop(health);
|
||||
let (mut query, _) = listener.accept().await.unwrap();
|
||||
let request = read_request(&mut query).await;
|
||||
started.send(()).unwrap();
|
||||
let (mut kill, _) =
|
||||
tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
|
||||
let kill_request = read_request(&mut kill).await;
|
||||
reply(&mut kill, "200 OK", "", "").await;
|
||||
(request, kill_request)
|
||||
});
|
||||
let source = DataSource {
|
||||
read_only: true,
|
||||
properties: vec![property("use_http_session", if stateless { "false" } else { "true" })],
|
||||
..source(port)
|
||||
};
|
||||
let pool = Pool::connect(&source, None, None).await.unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
|
||||
let cancelled = async {
|
||||
received.await.unwrap();
|
||||
cancel.cancel();
|
||||
};
|
||||
let (result, ()) = tokio::join!(query, cancelled);
|
||||
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
|
||||
let (query, kill) = server.await.unwrap();
|
||||
let query_id = query_value(&request_url(&query), "query_id").unwrap();
|
||||
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
|
||||
let url = request_url(&kill);
|
||||
assert_eq!(query_value(&url, "session_id"), None);
|
||||
assert_eq!(query_value(&url, "readonly").as_deref(), stateless.then_some("1"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -217,7 +217,8 @@ impl ManageConnection for MssqlConnectionManager {
|
||||
let row = client.simple_query("SELECT DB_NAME()").await?.into_row().await?;
|
||||
let default = row
|
||||
.and_then(|r| r.get::<&str, _>(0).map(str::to_owned))
|
||||
.and_then(|db| crate::sql::use_schema(DbDriver::SqlServer, &db));
|
||||
// Statements that `USE` another database must not move the pooled connection for good.
|
||||
.map(|db| format!("USE {}", crate::sql::quote_ident(DbDriver::SqlServer, &db)));
|
||||
Ok(MssqlConnection(Some(client), Context::new(default)))
|
||||
}
|
||||
|
||||
@@ -748,6 +749,14 @@ impl Pool {
|
||||
}
|
||||
|
||||
/// The keep-alive ping (Oracle needs a FROM clause).
|
||||
/// Keep-alive: one cheap round trip on the session.
|
||||
pub async fn ping(&self) -> IdeResult<()> {
|
||||
match self {
|
||||
Pool::Jdbc(p) => p.ping().await,
|
||||
_ => self.rows(self.ping_sql(), 1).await.map(|_| ()),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ping_sql(&self) -> &'static str {
|
||||
match self {
|
||||
Pool::Oracle(_) => "SELECT 1 FROM DUAL",
|
||||
|
||||
@@ -5,6 +5,7 @@ use crate::{DataSource, DbManager, QueryResult, ResultColumn};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::HashMap;
|
||||
use std::io::{Cursor, Read};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Stdio;
|
||||
@@ -302,7 +303,9 @@ async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>>
|
||||
const CANCEL_GRACE: Duration = Duration::from_secs(3);
|
||||
|
||||
fn cancel_timeout() -> IdeError {
|
||||
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
|
||||
IdeError::invalid(
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect.",
|
||||
)
|
||||
}
|
||||
|
||||
async fn exchange(
|
||||
@@ -458,6 +461,44 @@ impl JdbcPool {
|
||||
}
|
||||
|
||||
async fn request(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
|
||||
let result = self.exchange_once(fields, sql, cancel).await;
|
||||
if let Err(e) = &result
|
||||
&& fields.first() != Some(&"open")
|
||||
&& e.kind != ide_core::error::ErrorKind::Cancelled
|
||||
&& !self.is_closed()
|
||||
&& !self.session_valid().await
|
||||
{
|
||||
// The session is gone (a proxy or tunnel dropped the idle TCP connection): close the
|
||||
// pool so the next statement or Connect starts a new one instead of failing forever.
|
||||
self.close().await;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Keep-alive: checks the session (any SQL would be dialect-specific) and closes a dead one.
|
||||
pub(crate) async fn ping(&self) -> IdeResult<()> {
|
||||
if self.session_valid().await {
|
||||
return Ok(());
|
||||
}
|
||||
self.close().await;
|
||||
Err(IdeError::new(ide_core::error::ErrorKind::Io, "JDBC connection was lost"))
|
||||
}
|
||||
|
||||
/// Whether the JDBC session still works, asked after a failed statement.
|
||||
async fn session_valid(&self) -> bool {
|
||||
if self.bridge.lock().await.is_none() {
|
||||
return false;
|
||||
}
|
||||
let cancel = CancellationToken::new();
|
||||
match tokio::time::timeout(Duration::from_secs(10), self.exchange_once(&["valid"], "", &cancel)).await {
|
||||
Ok(Ok(result)) => {
|
||||
result.rows.first().and_then(|row| row.first()).cloned().flatten().as_deref() != Some("false")
|
||||
}
|
||||
Ok(Err(_)) | Err(_) => false,
|
||||
}
|
||||
}
|
||||
|
||||
async fn exchange_once(&self, fields: &[&str], sql: &str, cancel: &CancellationToken) -> IdeResult<QueryResult> {
|
||||
let mut slot = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
@@ -562,14 +603,32 @@ fn decode(data: &[u8], sql: &str, elapsed_ms: f64) -> IdeResult<QueryResult> {
|
||||
impl DbManager {
|
||||
pub(crate) async fn jdbc_completion(&self, id: &str, pool: &JdbcPool) -> IdeResult<crate::CompletionModel> {
|
||||
let mut tables = vec![];
|
||||
let schemas = self.schemas(id).await?;
|
||||
let mut column_count = 0;
|
||||
// Read the schemas the source's Schemas tab picks, like the database tree does. It also
|
||||
// keeps large instances usable: an Oracle server exposes dozens of system schemas, and
|
||||
// dumping the columns of all of them takes minutes, during which the bridge (a single
|
||||
// Java process that runs one command at a time) executes none of the user's statements.
|
||||
let introspection = self.source(id)?.introspection;
|
||||
let schemas: Vec<String> =
|
||||
self.schemas(id).await?.into_iter().filter(|s| introspection.shows_schema(s)).collect();
|
||||
for schema in &schemas {
|
||||
// Columns of the whole namespace in one call; a driver that refuses it still completes tables.
|
||||
let mut columns = if column_count < crate::MAX_META_ROWS {
|
||||
pool.metadata(&["schemaColumns", schema]).await.map(schema_columns).unwrap_or_else(|e| {
|
||||
tracing::warn!("JDBC columns of {schema}: {}", e.message);
|
||||
HashMap::new()
|
||||
})
|
||||
} else {
|
||||
HashMap::new()
|
||||
};
|
||||
for table in self.tables(id, schema).await? {
|
||||
let columns = columns.remove(&table.name).unwrap_or_default();
|
||||
column_count += columns.len();
|
||||
tables.push(crate::CompletionTable {
|
||||
schema: schema.clone(),
|
||||
name: table.name,
|
||||
kind: table.kind,
|
||||
columns: vec![],
|
||||
columns,
|
||||
});
|
||||
if tables.len() >= crate::MAX_META_ROWS {
|
||||
break;
|
||||
@@ -594,10 +653,49 @@ impl DbManager {
|
||||
}
|
||||
}
|
||||
|
||||
/// The bridge's `schemaColumns` rows (table, name, type, nullable, default) by table.
|
||||
fn schema_columns(rows: Vec<Vec<Option<String>>>) -> HashMap<String, Vec<crate::CompletionColumn>> {
|
||||
let mut by_table: HashMap<String, Vec<crate::CompletionColumn>> = HashMap::new();
|
||||
for row in rows {
|
||||
let mut it = row.into_iter();
|
||||
let (Some(Some(table)), Some(Some(name))) = (it.next(), it.next()) else { continue };
|
||||
let data_type = it.next().flatten().unwrap_or_default();
|
||||
let nullable = it.next().flatten().as_deref() != Some("0");
|
||||
let has_default = it.next().flatten().is_some();
|
||||
by_table.entry(table).or_default().push(crate::CompletionColumn {
|
||||
name,
|
||||
data_type,
|
||||
nullable,
|
||||
primary_key: false,
|
||||
has_default,
|
||||
});
|
||||
}
|
||||
by_table
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn schema_columns_group_by_table() {
|
||||
let row = |t: &str, n: &str, null: &str, def: Option<&str>| {
|
||||
vec![Some(t.into()), Some(n.into()), Some("INT".into()), Some(null.into()), def.map(Into::into)]
|
||||
};
|
||||
let by_table = schema_columns(vec![
|
||||
row("orders", "id", "0", None),
|
||||
row("orders", "note", "1", Some("'none'")),
|
||||
row("items", "sku", "1", None),
|
||||
vec![None, Some("orphan".into())],
|
||||
]);
|
||||
let orders = &by_table["orders"];
|
||||
assert_eq!(orders.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "note"]);
|
||||
assert_eq!((orders[0].nullable, orders[0].has_default), (false, false));
|
||||
assert_eq!((orders[1].nullable, orders[1].has_default), (true, true));
|
||||
assert_eq!(by_table["items"].len(), 1);
|
||||
assert_eq!(by_table.len(), 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn frame_codec_checks_both_16_mib_boundaries() {
|
||||
assert_eq!(encode(7, &["a"]).unwrap(), [0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 1, b'a']);
|
||||
|
||||
@@ -379,8 +379,8 @@ pub(crate) fn keep_alive(pool: &Arc<Pool>, every: Duration) {
|
||||
loop {
|
||||
tick.tick().await;
|
||||
let Some(p) = pool.upgrade().filter(|p| !p.is_closed()) else { break };
|
||||
if let Err(e) = p.rows(p.ping_sql(), 1).await {
|
||||
tracing::debug!("keep-alive: {}", e.message);
|
||||
if let Err(e) = p.ping().await {
|
||||
tracing::info!("keep-alive: {}", e.message);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -847,12 +847,12 @@ impl DbManager {
|
||||
}
|
||||
|
||||
pub fn is_connected(&self, id: &str) -> bool {
|
||||
self.pools.lock().contains_key(id)
|
||||
self.pools.lock().get(id).is_some_and(|p| !p.is_closed())
|
||||
}
|
||||
|
||||
/// Connected targets (data source ids, `<id>:<database>`).
|
||||
pub fn connected(&self) -> Vec<String> {
|
||||
self.pools.lock().keys().cloned().collect()
|
||||
self.pools.lock().iter().filter(|(_, p)| !p.is_closed()).map(|(id, _)| id.clone()).collect()
|
||||
}
|
||||
|
||||
/// The pool of target `id`, connecting first if needed.
|
||||
@@ -862,8 +862,13 @@ impl DbManager {
|
||||
if self.tunnels.lock().get(source_id).is_some_and(|t| t.is_closed()) {
|
||||
self.disconnect_source(source_id).await;
|
||||
}
|
||||
if let Some(p) = self.pools.lock().get(id) {
|
||||
return Ok(p.clone());
|
||||
let cached = self.pools.lock().get(id).cloned();
|
||||
if let Some(p) = cached {
|
||||
if !p.is_closed() {
|
||||
return Ok(p);
|
||||
}
|
||||
// The connection broke (a custom JDBC session whose TCP connection was dropped): reconnect.
|
||||
self.disconnect(id).await;
|
||||
}
|
||||
let source = self.source(id)?;
|
||||
let password = self.password(&source).await;
|
||||
@@ -917,7 +922,7 @@ impl DbManager {
|
||||
|
||||
/// Disconnects every database of data source `id`.
|
||||
pub async fn disconnect_source(&self, id: &str) {
|
||||
let targets: Vec<String> = self.connected().into_iter().filter(|t| split_target(t).0 == id).collect();
|
||||
let targets: Vec<String> = self.pools.lock().keys().filter(|t| split_target(t).0 == id).cloned().collect();
|
||||
for t in targets {
|
||||
self.disconnect(&t).await;
|
||||
}
|
||||
|
||||
@@ -124,6 +124,45 @@ impl Default for DbIntrospection {
|
||||
}
|
||||
}
|
||||
|
||||
impl DbIntrospection {
|
||||
/// Whether the tree shows this schema: every one with `all_schemas`, otherwise it has to
|
||||
/// match one of the `schemas` patterns. The completion model uses the same test, so it
|
||||
/// offers exactly the tables the tree lists (and does not read the ones it never shows).
|
||||
pub fn shows_schema(&self, name: &str) -> bool {
|
||||
self.all_schemas
|
||||
|| self.schemas.iter().map(|p| p.trim()).filter(|p| !p.is_empty()).any(|p| schema_matches(p, name))
|
||||
}
|
||||
}
|
||||
|
||||
/// `*` matches any run of characters, `?` a single one; a pattern without wildcards matches the
|
||||
/// name as typed (the dialog fills names from the list the server returned, so case is settled).
|
||||
fn schema_matches(pattern: &str, name: &str) -> bool {
|
||||
if !pattern.contains('*') && !pattern.contains('?') {
|
||||
return pattern == name;
|
||||
}
|
||||
let p: Vec<char> = pattern.chars().collect();
|
||||
let n: Vec<char> = name.chars().collect();
|
||||
let (mut pi, mut ni) = (0, 0);
|
||||
// Position of the last `*` and how much of the name it has already swallowed.
|
||||
let mut star: Option<(usize, usize)> = None;
|
||||
while ni < n.len() {
|
||||
if pi < p.len() && (p[pi] == '?' || p[pi] == n[ni]) {
|
||||
pi += 1;
|
||||
ni += 1;
|
||||
} else if pi < p.len() && p[pi] == '*' {
|
||||
star = Some((pi, ni));
|
||||
pi += 1;
|
||||
} else if let Some((at, taken)) = star {
|
||||
pi = at + 1;
|
||||
ni = taken + 1;
|
||||
star = Some((at, taken + 1));
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
p[pi..].iter().all(|&c| c == '*')
|
||||
}
|
||||
|
||||
/// Advanced tab: a driver property. PostgreSQL: run-time parameters (and
|
||||
/// `application_name`); MySQL: session variables (and `charset`, `collation`);
|
||||
/// SQLite: pragmas. See [`crate::conn`].
|
||||
@@ -765,4 +804,24 @@ mod tests {
|
||||
assert_eq!(r.snowflake().auth, DbSnowflakeAuth::Browser);
|
||||
assert_eq!(scheme_driver("snowflake"), Some(DbDriver::Snowflake));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn introspection_shows_only_the_picked_schemas() {
|
||||
let mut i = DbIntrospection::default();
|
||||
assert!(i.shows_schema("SYS"), "the default reads every schema");
|
||||
|
||||
i.all_schemas = false;
|
||||
assert!(!i.shows_schema("SYS"), "nothing picked: the tree lists nothing either");
|
||||
|
||||
i.schemas = vec!["XMCB".into(), " APP_* ".into()];
|
||||
assert!(i.shows_schema("XMCB"));
|
||||
assert!(i.shows_schema("APP_INFO"));
|
||||
assert!(!i.shows_schema("APP"), "`*` needs the text that follows it");
|
||||
assert!(!i.shows_schema("SYS"));
|
||||
assert!(!i.shows_schema("xmcb"), "patterns match the names the server returned");
|
||||
|
||||
i.schemas = vec!["?".into()];
|
||||
assert!(i.shows_schema("A"));
|
||||
assert!(!i.shows_schema("AB"));
|
||||
}
|
||||
}
|
||||
@@ -442,7 +442,8 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
|
||||
DbDriver::Sqlite | DbDriver::Jdbc => None,
|
||||
DbDriver::Postgres => Some("SELECT current_schema()"),
|
||||
DbDriver::Mysql => Some("SELECT DATABASE()"),
|
||||
DbDriver::SqlServer => Some("SELECT DB_NAME()"),
|
||||
// The login's default schema; the database is the console's target (IDEA's `database.schema`).
|
||||
DbDriver::SqlServer => Some("SELECT SCHEMA_NAME()"),
|
||||
DbDriver::Oracle => Some("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL"),
|
||||
DbDriver::Snowflake => Some("SELECT CURRENT_SCHEMA()"),
|
||||
}
|
||||
@@ -450,12 +451,13 @@ pub fn current_schema(driver: DbDriver) -> Option<&'static str> {
|
||||
|
||||
/// The statement that makes unqualified names resolve in `schema` on the
|
||||
/// connection that runs it (a query console's active schema; `None`: the driver
|
||||
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs).
|
||||
/// has no schema to switch — SQLite's `main`, ClickHouse's `USE` differs, and SQL Server
|
||||
/// cannot change a session's default schema, so its console schema only scopes resolution).
|
||||
pub fn use_schema(driver: DbDriver, schema: &str) -> Option<String> {
|
||||
match driver {
|
||||
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc => None,
|
||||
DbDriver::Sqlite | DbDriver::Clickhouse | DbDriver::Jdbc | DbDriver::SqlServer => None,
|
||||
DbDriver::Postgres => Some(format!("SET search_path TO {}", quote_ident(driver, schema))),
|
||||
DbDriver::Mysql | DbDriver::SqlServer => Some(format!("USE {}", quote_ident(driver, schema))),
|
||||
DbDriver::Mysql => Some(format!("USE {}", quote_ident(driver, schema))),
|
||||
DbDriver::Oracle => Some(format!("ALTER SESSION SET CURRENT_SCHEMA = {}", quote_ident(driver, schema))),
|
||||
DbDriver::Snowflake => Some(format!("USE SCHEMA {}", quote_ident(driver, schema))),
|
||||
}
|
||||
@@ -1030,7 +1032,7 @@ mod tests {
|
||||
assert_eq!(quote_ident(DbDriver::SqlServer, "a]b"), "[a]]b]");
|
||||
assert_eq!(qualified(DbDriver::SqlServer, "dbo", "t"), "[dbo].[t]");
|
||||
assert_eq!(qualified(DbDriver::SqlServer, "", "t"), "[t]");
|
||||
assert_eq!(current_schema(DbDriver::SqlServer), Some("SELECT DB_NAME()"));
|
||||
assert_eq!(current_schema(DbDriver::SqlServer), Some("SELECT SCHEMA_NAME()"));
|
||||
assert_eq!(crate::conn::begin_statement(DbDriver::SqlServer), "BEGIN TRAN");
|
||||
assert_eq!(
|
||||
schemas(DbDriver::SqlServer, true),
|
||||
@@ -1149,7 +1151,7 @@ mod tests {
|
||||
fn schema_switch_statement_per_dialect() {
|
||||
assert_eq!(use_schema(DbDriver::Postgres, "app data"), Some("SET search_path TO \"app data\"".into()));
|
||||
assert_eq!(use_schema(DbDriver::Mysql, "a`b"), Some("USE `a``b`".into()));
|
||||
assert_eq!(use_schema(DbDriver::SqlServer, "app] data"), Some("USE [app]] data]".into()));
|
||||
assert_eq!(use_schema(DbDriver::SqlServer, "dbo"), None);
|
||||
assert_eq!(use_schema(DbDriver::Postgres, "a\"b"), Some("SET search_path TO \"a\"\"b\"".into()));
|
||||
assert_eq!(use_schema(DbDriver::Oracle, "a\"b"), Some("ALTER SESSION SET CURRENT_SCHEMA = \"a\"\"b\"".into()));
|
||||
assert!(sqlserver_databases().contains("state = 0 AND HAS_DBACCESS(name) = 1"));
|
||||
|
||||
@@ -90,7 +90,10 @@ async fn duckdb_custom_driver_through_database_manager() -> IdeResult<()> {
|
||||
assert!(result.has_more);
|
||||
assert_eq!(result.rows, vec![vec![Some("1".into()), None]]);
|
||||
assert_eq!(result.columns[1].name, "label");
|
||||
assert_eq!(db.completion("test").await?.default_schema, "main");
|
||||
let completion = db.completion("test").await?;
|
||||
assert_eq!(completion.default_schema, "main");
|
||||
let items = completion.tables.iter().find(|t| t.schema == "main" && t.name == "items").expect("items");
|
||||
assert_eq!(items.columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), ["id", "label"]);
|
||||
db.execute("test", "create temporary table session_marker as select 42 as id", 1, &c).await?;
|
||||
let stop = CancellationToken::new();
|
||||
let (cancelled, ()) =
|
||||
@@ -207,9 +210,46 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
|
||||
})
|
||||
.await
|
||||
.expect("driver cancellation must be bounded");
|
||||
assert!(result.unwrap_err().message.contains("Reconnect"));
|
||||
assert_eq!(
|
||||
result.unwrap_err().message,
|
||||
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect."
|
||||
);
|
||||
assert!(db.connected().is_empty());
|
||||
assert_eq!(db.execute("test", "after cancellation", 1, &normal).await?.affected, Some(1.0));
|
||||
assert_eq!(db.connected(), ["test"]);
|
||||
db.disconnect("test").await;
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires JDBC_FIXTURE_JAR (java/jdbc-bridge/build.py --test --out fixture.jar) and Java 17+"]
|
||||
async fn a_lost_session_reconnects_on_the_next_statement() -> IdeResult<()> {
|
||||
let tmp = tempfile::tempdir()?;
|
||||
let db = manager(tmp.path());
|
||||
db.save_jdbc_driver(DbJdbcDriver {
|
||||
id: "fixture".into(),
|
||||
name: "Fixture".into(),
|
||||
jars: vec![std::env::var("JDBC_FIXTURE_JAR").unwrap()],
|
||||
class_name: "ai.openidea.jdbc.SelfTest$Fixture".into(),
|
||||
url_template: String::new(),
|
||||
})?;
|
||||
let source = DataSource {
|
||||
id: "test".into(),
|
||||
name: "Fixture".into(),
|
||||
driver: DbDriver::Jdbc,
|
||||
global: true,
|
||||
jdbc_driver: "fixture".into(),
|
||||
url: "jdbc:fixture:".into(),
|
||||
..Default::default()
|
||||
};
|
||||
db.save_sources(vec![source]).await?;
|
||||
let cancel = CancellationToken::new();
|
||||
db.execute("test", "first", 1, &cancel).await?;
|
||||
// The fixture's session reports itself invalid after "drop", like a connection a proxy reset.
|
||||
assert!(db.execute("test", "drop", 1, &cancel).await.unwrap_err().message.contains("connection reset"));
|
||||
assert!(!db.is_connected("test"), "a lost session is no longer listed as connected");
|
||||
assert_eq!(db.execute("test", "after reconnect", 1, &cancel).await?.affected, Some(1.0));
|
||||
assert!(db.is_connected("test"));
|
||||
db.disconnect("test").await;
|
||||
Ok(())
|
||||
}
|
||||
@@ -7,9 +7,10 @@
|
||||
|
||||
use crate::{
|
||||
COMPOSE_DIR, COMPOSE_FILES, COMPOSE_PROJECT, COMPOSE_SERVICE, ContainerOp, DockerAvailability, DockerContainer,
|
||||
DockerEndpoint, DockerImage, DockerNetwork, DockerObject, DockerSnapshot, DockerVolume, split_csv,
|
||||
DockerEndpoint, DockerImage, DockerImageLayer, DockerLogLine, DockerNetwork, DockerObject, DockerProcessList,
|
||||
DockerSnapshot, DockerVolume, split_csv,
|
||||
};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde::Deserialize;
|
||||
use std::collections::BTreeMap;
|
||||
use std::io::{Read, Write};
|
||||
@@ -193,9 +194,15 @@ fn request(addr: &Address, method: &str, path: &str, timeout: Duration) -> IdeRe
|
||||
read_response(&mut conn)
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response: head until `\r\n\r\n`, then the body per its
|
||||
/// framing (chunked, `Content-Length`, or until the connection closes).
|
||||
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
/// A response's status line and body framing.
|
||||
struct Head {
|
||||
status: u16,
|
||||
chunked: bool,
|
||||
length: Option<usize>,
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response head until `\r\n\r\n`.
|
||||
fn read_head(stream: &mut impl Read) -> IdeResult<Head> {
|
||||
let mut head: Vec<u8> = Vec::new();
|
||||
let mut byte = [0u8; 1];
|
||||
loop {
|
||||
@@ -228,16 +235,27 @@ fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
length = value.parse().ok();
|
||||
}
|
||||
}
|
||||
let body = if chunked {
|
||||
Ok(Head { status, chunked, length })
|
||||
}
|
||||
|
||||
/// Reads an HTTP/1.1 response: its head, then the body per its framing
|
||||
/// (chunked, `Content-Length`, or until the connection closes).
|
||||
fn read_response(stream: &mut impl Read) -> IdeResult<Response> {
|
||||
let head = read_head(stream)?;
|
||||
let body = read_body(stream, &head)?;
|
||||
Ok(Response { status: head.status, body })
|
||||
}
|
||||
|
||||
fn read_body(stream: &mut impl Read, head: &Head) -> IdeResult<Vec<u8>> {
|
||||
Ok(if head.chunked {
|
||||
read_chunked(stream)?
|
||||
} else if let Some(n) = length {
|
||||
} else if let Some(n) = head.length {
|
||||
read_exact_n(stream, n)?
|
||||
} else {
|
||||
let mut body = Vec::new();
|
||||
stream.read_to_end(&mut body)?;
|
||||
body
|
||||
};
|
||||
Ok(Response { status, body })
|
||||
})
|
||||
}
|
||||
|
||||
/// Reads one `\n`-terminated line (returned without it).
|
||||
@@ -482,6 +500,292 @@ pub(crate) fn inspect(
|
||||
})())
|
||||
}
|
||||
|
||||
/// The processes running in a container (`docker top`).
|
||||
pub(crate) fn container_top(ep: &DockerEndpoint, id: &str, timeout: Duration) -> Option<IdeResult<DockerProcessList>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
let body = check(request(&addr, "GET", &format!("/containers/{}/top", path_segment(id)), timeout)?)?;
|
||||
serde_json::from_str::<ApiTop>(&body)
|
||||
.map(|t| DockerProcessList { titles: t.titles, processes: t.processes })
|
||||
.map_err(|e| IdeError::internal(format!("the Docker daemon's process list is not JSON: {e}")))
|
||||
})())
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiTop {
|
||||
titles: Vec<String>,
|
||||
processes: Vec<Vec<String>>,
|
||||
}
|
||||
|
||||
/// An image's layers, newest first (`docker image history`).
|
||||
pub(crate) fn image_history(
|
||||
ep: &DockerEndpoint,
|
||||
id: &str,
|
||||
timeout: Duration,
|
||||
) -> Option<IdeResult<Vec<DockerImageLayer>>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
let body = check(request(&addr, "GET", &format!("/images/{}/history", path_segment(id)), timeout)?)?;
|
||||
let layers = serde_json::from_str::<Vec<ApiLayer>>(&body)
|
||||
.map_err(|e| IdeError::internal(format!("the Docker daemon's image history is not JSON: {e}")))?;
|
||||
Ok(map_layers(layers, unix_now()))
|
||||
})())
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiLayer {
|
||||
id: String,
|
||||
created: i64,
|
||||
created_by: String,
|
||||
size: i64,
|
||||
comment: String,
|
||||
}
|
||||
|
||||
fn map_layers(layers: Vec<ApiLayer>, now: i64) -> Vec<DockerImageLayer> {
|
||||
layers
|
||||
.into_iter()
|
||||
.map(|l| DockerImageLayer {
|
||||
id: l.id,
|
||||
created_by: l.created_by,
|
||||
size: human_size(l.size),
|
||||
created_since: human_duration((now - l.created).max(0)),
|
||||
created_at: unix_utc(l.created),
|
||||
comment: l.comment,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn unix_now() -> i64 {
|
||||
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs() as i64).unwrap_or(0)
|
||||
}
|
||||
|
||||
/// How often a log stream that has nothing to read checks for cancellation.
|
||||
const LOG_POLL: Duration = Duration::from_millis(200);
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiContainerInspect {
|
||||
config: ApiContainerConfig,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Default)]
|
||||
#[serde(rename_all = "PascalCase", default)]
|
||||
struct ApiContainerConfig {
|
||||
tty: bool,
|
||||
}
|
||||
|
||||
/// Streams a container's logs (`tail` last lines, then follows while `follow`)
|
||||
/// from `ep`'s daemon until they end or `cancel` fires.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub(crate) fn logs(
|
||||
ep: &DockerEndpoint,
|
||||
id: &str,
|
||||
tail: u32,
|
||||
follow: bool,
|
||||
timestamps: bool,
|
||||
timeout: Duration,
|
||||
cancel: &CancellationToken,
|
||||
on_line: &dyn Fn(DockerLogLine),
|
||||
) -> Option<IdeResult<()>> {
|
||||
let addr = address(ep)?;
|
||||
Some((|| {
|
||||
// A TTY container's log is one raw stream; otherwise it is framed per stream.
|
||||
let body = check(request(&addr, "GET", &format!("/containers/{}/json", path_segment(id)), timeout)?)?;
|
||||
let tty = serde_json::from_str::<ApiContainerInspect>(&body).map(|c| c.config.tty).unwrap_or(false);
|
||||
let path = format!(
|
||||
"/containers/{}/logs?stdout=1&stderr=1&tail={tail}&follow={}×tamps={}",
|
||||
path_segment(id),
|
||||
u8::from(follow),
|
||||
u8::from(timestamps),
|
||||
);
|
||||
let mut conn = Conn::connect(&addr, timeout)?;
|
||||
conn.write_all(
|
||||
format!("GET {path} HTTP/1.1\r\nHost: docker\r\nUser-Agent: openidea\r\nConnection: close\r\n\r\n")
|
||||
.as_bytes(),
|
||||
)?;
|
||||
let head = read_head(&mut conn)?;
|
||||
if !(200..300).contains(&head.status) {
|
||||
let body = read_body(&mut conn, &head)?;
|
||||
check(Response { status: head.status, body })?;
|
||||
}
|
||||
conn.set_timeouts(LOG_POLL);
|
||||
let mut decoder = LogDecoder::new(&head, tty);
|
||||
let mut buf = [0u8; 8192];
|
||||
while !decoder.done() {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
match conn.read(&mut buf) {
|
||||
Ok(0) => break,
|
||||
Ok(n) => decoder.feed(&buf[..n], &mut |line| on_line(line))?,
|
||||
Err(e)
|
||||
if matches!(
|
||||
e.kind(),
|
||||
std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut | std::io::ErrorKind::Interrupted
|
||||
) => {}
|
||||
Err(e) => return Err(e.into()),
|
||||
}
|
||||
}
|
||||
decoder.finish(&mut |line| on_line(line));
|
||||
Ok(())
|
||||
})())
|
||||
}
|
||||
|
||||
/// Turns a log response body, as it arrives, into lines: undoes the chunked
|
||||
/// transfer encoding, then the per-stream frames (8-byte header: stream, 3 zero
|
||||
/// bytes, big-endian length) unless the container has a TTY.
|
||||
struct LogDecoder {
|
||||
body: BodyFraming,
|
||||
tty: bool,
|
||||
header: Vec<u8>,
|
||||
frame_left: usize,
|
||||
frame_stderr: bool,
|
||||
/// Partial lines of stdout and stderr.
|
||||
partial: [Vec<u8>; 2],
|
||||
}
|
||||
|
||||
enum BodyFraming {
|
||||
Chunked { state: ChunkState, line: Vec<u8> },
|
||||
Length(usize),
|
||||
Close,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
enum ChunkState {
|
||||
Size,
|
||||
Data(usize),
|
||||
DataEnd,
|
||||
Trailer,
|
||||
Done,
|
||||
}
|
||||
|
||||
impl LogDecoder {
|
||||
fn new(head: &Head, tty: bool) -> Self {
|
||||
let body = if head.chunked {
|
||||
BodyFraming::Chunked { state: ChunkState::Size, line: Vec::new() }
|
||||
} else if let Some(n) = head.length {
|
||||
BodyFraming::Length(n)
|
||||
} else {
|
||||
BodyFraming::Close
|
||||
};
|
||||
Self { body, tty, header: Vec::new(), frame_left: 0, frame_stderr: false, partial: [Vec::new(), Vec::new()] }
|
||||
}
|
||||
|
||||
fn done(&self) -> bool {
|
||||
matches!(self.body, BodyFraming::Chunked { state: ChunkState::Done, .. } | BodyFraming::Length(0))
|
||||
}
|
||||
|
||||
fn feed(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) -> IdeResult<()> {
|
||||
let mut payload = Vec::new();
|
||||
match &mut self.body {
|
||||
BodyFraming::Close => payload.extend_from_slice(bytes),
|
||||
BodyFraming::Length(left) => {
|
||||
let take = (*left).min(bytes.len());
|
||||
payload.extend_from_slice(&bytes[..take]);
|
||||
*left -= take;
|
||||
}
|
||||
BodyFraming::Chunked { state, line } => {
|
||||
while !bytes.is_empty() {
|
||||
match *state {
|
||||
ChunkState::Done => break,
|
||||
ChunkState::Data(n) => {
|
||||
let take = n.min(bytes.len());
|
||||
payload.extend_from_slice(&bytes[..take]);
|
||||
bytes = &bytes[take..];
|
||||
*state = if take == n { ChunkState::DataEnd } else { ChunkState::Data(n - take) };
|
||||
}
|
||||
_ => {
|
||||
let b = bytes[0];
|
||||
bytes = &bytes[1..];
|
||||
if b != b'\n' {
|
||||
if b != b'\r' {
|
||||
line.push(b);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let text = String::from_utf8_lossy(line).into_owned();
|
||||
line.clear();
|
||||
*state = match *state {
|
||||
ChunkState::Size => {
|
||||
let size = text.split(';').next().unwrap_or_default().trim();
|
||||
match usize::from_str_radix(size, 16) {
|
||||
Ok(0) => ChunkState::Trailer,
|
||||
Ok(n) => ChunkState::Data(n),
|
||||
Err(_) => {
|
||||
return Err(IdeError::internal(
|
||||
"the Docker daemon answered with a malformed chunked response",
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
ChunkState::DataEnd => ChunkState::Size,
|
||||
_ if text.is_empty() => ChunkState::Done,
|
||||
other => other,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
self.frames(&payload, emit);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn frames(&mut self, mut bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
if self.tty {
|
||||
self.lines(false, bytes, emit);
|
||||
return;
|
||||
}
|
||||
while !bytes.is_empty() {
|
||||
if self.frame_left == 0 {
|
||||
let take = (8 - self.header.len()).min(bytes.len());
|
||||
self.header.extend_from_slice(&bytes[..take]);
|
||||
bytes = &bytes[take..];
|
||||
if self.header.len() == 8 {
|
||||
self.frame_stderr = self.header[0] == 2;
|
||||
self.frame_left =
|
||||
u32::from_be_bytes([self.header[4], self.header[5], self.header[6], self.header[7]]) as usize;
|
||||
self.header.clear();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let take = self.frame_left.min(bytes.len());
|
||||
self.lines(self.frame_stderr, &bytes[..take], emit);
|
||||
self.frame_left -= take;
|
||||
bytes = &bytes[take..];
|
||||
}
|
||||
}
|
||||
|
||||
fn lines(&mut self, stderr: bool, bytes: &[u8], emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
let partial = &mut self.partial[usize::from(stderr)];
|
||||
for &b in bytes {
|
||||
if b == b'\n' {
|
||||
emit(DockerLogLine { stderr, text: line_text(partial) });
|
||||
partial.clear();
|
||||
} else {
|
||||
partial.push(b);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Emits the last lines that ended without a newline.
|
||||
fn finish(&mut self, emit: &mut dyn FnMut(DockerLogLine)) {
|
||||
for stderr in [false, true] {
|
||||
let partial = &mut self.partial[usize::from(stderr)];
|
||||
if !partial.is_empty() {
|
||||
emit(DockerLogLine { stderr, text: line_text(partial) });
|
||||
partial.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn line_text(bytes: &[u8]) -> String {
|
||||
String::from_utf8_lossy(bytes.strip_suffix(b"\r").unwrap_or(bytes)).into_owned()
|
||||
}
|
||||
|
||||
/// One URL path segment, percent-encoded so an id cannot change the path.
|
||||
fn path_segment(id: &str) -> String {
|
||||
let mut out = String::with_capacity(id.len());
|
||||
@@ -817,6 +1121,75 @@ mod tests {
|
||||
assert!(read_response(&mut &garbage[..]).is_err());
|
||||
}
|
||||
|
||||
/// Feeds `body` one byte at a time, as a slow connection delivers it.
|
||||
fn decode(head: Head, tty: bool, body: &[u8]) -> (Vec<(bool, String)>, bool) {
|
||||
let mut lines = Vec::new();
|
||||
let mut decoder = LogDecoder::new(&head, tty);
|
||||
for b in body {
|
||||
decoder.feed(std::slice::from_ref(b), &mut |l| lines.push((l.stderr, l.text))).unwrap();
|
||||
}
|
||||
let done = decoder.done();
|
||||
decoder.finish(&mut |l| lines.push((l.stderr, l.text)));
|
||||
(lines, done)
|
||||
}
|
||||
|
||||
fn frame(stream: u8, text: &str) -> Vec<u8> {
|
||||
let mut f = vec![stream, 0, 0, 0];
|
||||
f.extend((text.len() as u32).to_be_bytes());
|
||||
f.extend(text.as_bytes());
|
||||
f
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn engine_image_history_reads_like_the_cli() {
|
||||
let layers: Vec<ApiLayer> = serde_json::from_str(
|
||||
r#"[{"Id":"sha256:abc","Created":1000,"CreatedBy":"CMD [\"python3\"]","Size":20500,"Comment":"buildkit","Tags":["py:3"]},
|
||||
{"Id":"<missing>","Created":940,"CreatedBy":"RUN x","Size":0,"Comment":""}]"#,
|
||||
)
|
||||
.unwrap();
|
||||
let rows = map_layers(layers, 1000 + 2 * 7 * 86_400);
|
||||
assert_eq!(
|
||||
rows.iter().map(|l| (l.id.as_str(), l.size.as_str(), l.created_since.as_str())).collect::<Vec<_>>(),
|
||||
[("sha256:abc", "20.5kB", "2 weeks ago"), ("<missing>", "0B", "2 weeks ago")]
|
||||
);
|
||||
assert_eq!(rows[0].created_by, "CMD [\"python3\"]");
|
||||
let top: ApiTop = serde_json::from_str(r#"{"Titles":["PID","CMD"],"Processes":[["1","sh"]]}"#).unwrap();
|
||||
assert_eq!(
|
||||
(top.titles, top.processes),
|
||||
(vec!["PID".to_owned(), "CMD".to_owned()], vec![vec!["1".to_owned(), "sh".to_owned()]])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn container_logs_split_into_stream_lines_across_chunks_and_frames() {
|
||||
// Frames split mid-line, a CRLF line, and a stderr line between stdout parts.
|
||||
let mut framed = frame(1, "tick 1\r\ntick");
|
||||
framed.extend(frame(2, "oops\n"));
|
||||
framed.extend(frame(1, " 2\nlast"));
|
||||
let mut chunked = Vec::new();
|
||||
for part in framed.chunks(7) {
|
||||
chunked.extend(format!("{:x}\r\n", part.len()).as_bytes());
|
||||
chunked.extend(part);
|
||||
chunked.extend(b"\r\n");
|
||||
}
|
||||
chunked.extend(b"0\r\n\r\n");
|
||||
let (lines, done) = decode(Head { status: 200, chunked: true, length: None }, false, &chunked);
|
||||
assert!(done);
|
||||
let expected = [(false, "tick 1"), (true, "oops"), (false, "tick 2"), (false, "last")];
|
||||
assert_eq!(lines, expected.map(|(e, t)| (e, t.to_owned())));
|
||||
|
||||
// A TTY container's log is one raw stream; the body may end with the connection.
|
||||
let (lines, done) = decode(Head { status: 200, chunked: false, length: None }, true, b"a\r\nb\n");
|
||||
assert!(!done);
|
||||
assert_eq!(lines, [(false, "a".to_owned()), (false, "b".to_owned())]);
|
||||
|
||||
// A Content-Length body ends after its length.
|
||||
let body = frame(1, "one\n");
|
||||
let (lines, done) = decode(Head { status: 200, chunked: false, length: Some(body.len()) }, false, &body);
|
||||
assert!(done);
|
||||
assert_eq!(lines, [(false, "one".to_owned())]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn daemon_errors_carry_their_message() {
|
||||
let resp = Response { status: 404, body: br#"{"message":"No such container: missing"}"#.to_vec() };
|
||||
|
||||
@@ -287,6 +287,11 @@ fn check_id(id: &str) -> IdeResult<&str> {
|
||||
/// `docker image history --no-trunc --format '{{json .}}'` of one image.
|
||||
pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImageLayer>> {
|
||||
let id = check_id(id)?;
|
||||
if docker_executable().is_none()
|
||||
&& let Some(layers) = engine::image_history(ep, id, QUICK)
|
||||
{
|
||||
return layers;
|
||||
}
|
||||
let out = run(ep, &["image", "history", "--no-trunc", "--format", "{{json .}}", id], QUICK)?;
|
||||
Ok(parse_image_history(&out))
|
||||
}
|
||||
@@ -294,6 +299,11 @@ pub fn image_history(ep: &DockerEndpoint, id: &str) -> IdeResult<Vec<DockerImage
|
||||
/// `docker top <id>` of a running container.
|
||||
pub fn container_top(ep: &DockerEndpoint, id: &str) -> IdeResult<DockerProcessList> {
|
||||
let id = check_id(id)?;
|
||||
if docker_executable().is_none()
|
||||
&& let Some(processes) = engine::container_top(ep, id, QUICK)
|
||||
{
|
||||
return processes;
|
||||
}
|
||||
let out = run(ep, &["top", id], QUICK)?;
|
||||
Ok(parse_container_top(&out))
|
||||
}
|
||||
@@ -316,6 +326,11 @@ pub fn logs(
|
||||
cancel: &CancellationToken,
|
||||
on_line: &dyn Fn(DockerLogLine),
|
||||
) -> IdeResult<()> {
|
||||
if docker_executable().is_none()
|
||||
&& let Some(streamed) = engine::logs(ep, id, tail, follow, timestamps, QUICK, cancel, on_line)
|
||||
{
|
||||
return streamed;
|
||||
}
|
||||
let tail = tail.to_string();
|
||||
let mut args = vec!["logs", "--tail", &tail];
|
||||
if follow {
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
[package]
|
||||
name = "ide-drag-out"
|
||||
description = "OS file drags out of an app window, so file managers and transfer clients copy the files: GTK on Linux, OLE on Windows, AppKit on macOS"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
gtk = "0.18"
|
||||
|
||||
[target.'cfg(any(windows, target_os = "macos"))'.dependencies]
|
||||
raw-window-handle = "0.6"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows = { version = "0.62", features = [
|
||||
"Win32_Foundation",
|
||||
"Win32_Graphics_Gdi",
|
||||
"Win32_System_Com",
|
||||
"Win32_System_Com_StructuredStorage",
|
||||
"Win32_System_Memory",
|
||||
"Win32_System_Ole",
|
||||
"Win32_System_SystemServices",
|
||||
"Win32_UI_Shell",
|
||||
"Win32_UI_Shell_Common",
|
||||
] }
|
||||
# `#[implement]` expands to paths into `windows_core`.
|
||||
windows-core = "0.62"
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
objc2 = { version = "0.6", default-features = false, features = ["std"] }
|
||||
objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSGeometry", "NSObject", "NSString", "NSURL"] }
|
||||
objc2-app-kit = { version = "0.3", default-features = false, features = [
|
||||
"std",
|
||||
"objc2-core-foundation",
|
||||
"NSApplication",
|
||||
"NSDragging",
|
||||
"NSDraggingItem",
|
||||
"NSDraggingSession",
|
||||
"NSEvent",
|
||||
"NSGraphics",
|
||||
"NSGraphicsContext",
|
||||
"NSImage",
|
||||
"NSPasteboard",
|
||||
"NSPasteboardItem",
|
||||
"NSResponder",
|
||||
"NSView",
|
||||
"NSWindow",
|
||||
"NSWorkspace",
|
||||
] }
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
@@ -0,0 +1,122 @@
|
||||
//! macOS: an AppKit dragging session with one pasteboard item per path, each a file URL.
|
||||
|
||||
use super::Outcome;
|
||||
use objc2::rc::Retained;
|
||||
use objc2::runtime::ProtocolObject;
|
||||
use objc2::{AnyThread, DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
|
||||
use objc2_app_kit::{
|
||||
NSApplication, NSDragOperation, NSDraggingContext, NSDraggingItem, NSDraggingSession, NSDraggingSource, NSEvent,
|
||||
NSEventModifierFlags, NSEventType, NSPasteboardItem, NSPasteboardTypeFileURL, NSView, NSWorkspace,
|
||||
};
|
||||
use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString, NSURL};
|
||||
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
|
||||
use std::cell::Cell;
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// The size of each file's icon under the pointer, in points.
|
||||
const ICON_SIZE: f64 = 32.0;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`, each shown with its
|
||||
/// Finder icon; `done` runs on the main thread when the drag ends.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let mtm = MainThreadMarker::new().ok_or_else(|| io::Error::other("a drag starts on the main thread"))?;
|
||||
let RawWindowHandle::AppKit(handle) =
|
||||
window.window_handle().map_err(|error| io::Error::other(error.to_string()))?.as_raw()
|
||||
else {
|
||||
return Err(io::Error::other("not an AppKit window"));
|
||||
};
|
||||
// SAFETY: the handle names this window's view, alive while `window` is borrowed.
|
||||
let view = unsafe { handle.ns_view.cast::<NSView>().as_ref() };
|
||||
let window = view.window().ok_or_else(|| io::Error::other("the view has no window"))?;
|
||||
let content = window.contentView().ok_or_else(|| io::Error::other("the window has no content view"))?;
|
||||
// In window coordinates, which are the content view's.
|
||||
let pointer = window.mouseLocationOutsideOfEventStream();
|
||||
let frame = NSRect::new(
|
||||
NSPoint::new(pointer.x - ICON_SIZE / 2.0, pointer.y - ICON_SIZE / 2.0),
|
||||
NSSize::new(ICON_SIZE, ICON_SIZE),
|
||||
);
|
||||
|
||||
let workspace = NSWorkspace::sharedWorkspace();
|
||||
let mut items = Vec::with_capacity(paths.len());
|
||||
for path in &paths {
|
||||
let path = NSString::from_str(&path.to_string_lossy());
|
||||
let url = NSURL::fileURLWithPath(&path)
|
||||
.absoluteString()
|
||||
.ok_or_else(|| io::Error::other(format!("not a file URL: {path}")))?;
|
||||
let item = NSPasteboardItem::new();
|
||||
if !item.setString_forType(&url, unsafe { NSPasteboardTypeFileURL }) {
|
||||
return Err(io::Error::other(format!("cannot put {path} on the pasteboard")));
|
||||
}
|
||||
let drag_item =
|
||||
NSDraggingItem::initWithPasteboardWriter(NSDraggingItem::alloc(), ProtocolObject::from_ref(&*item));
|
||||
let icon = workspace.iconForFile(&path);
|
||||
unsafe { drag_item.setDraggingFrame_contents(frame, Some(&icon)) };
|
||||
items.push(drag_item);
|
||||
}
|
||||
|
||||
// The session starts from a drag event at the pointer: the web view's own mouse events
|
||||
// went to WebKit, and the current event may be a later one.
|
||||
let timestamp = NSApplication::sharedApplication(mtm).currentEvent().map_or(0.0, |event| event.timestamp());
|
||||
let event = NSEvent::mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure(
|
||||
NSEventType::LeftMouseDragged,
|
||||
pointer,
|
||||
NSEventModifierFlags::empty(),
|
||||
timestamp,
|
||||
window.windowNumber(),
|
||||
None,
|
||||
0,
|
||||
1,
|
||||
1.0,
|
||||
)
|
||||
.ok_or_else(|| io::Error::other("cannot make the drag event"))?;
|
||||
let source = DragSource::new(Box::new(done), mtm);
|
||||
content.beginDraggingSessionWithItems_event_source(
|
||||
&NSArray::from_retained_slice(&items),
|
||||
&event,
|
||||
ProtocolObject::from_ref(&*source),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
type Done = Box<dyn FnOnce(Outcome)>;
|
||||
|
||||
struct Ivars {
|
||||
done: Cell<Option<Done>>,
|
||||
}
|
||||
|
||||
define_class!(
|
||||
#[unsafe(super(NSObject))]
|
||||
#[thread_kind = MainThreadOnly]
|
||||
#[name = "OpenIdeaDragOutSource"]
|
||||
#[ivars = Ivars]
|
||||
struct DragSource;
|
||||
|
||||
unsafe impl NSObjectProtocol for DragSource {}
|
||||
|
||||
unsafe impl NSDraggingSource for DragSource {
|
||||
#[unsafe(method(draggingSession:sourceOperationMaskForDraggingContext:))]
|
||||
fn operation_mask(&self, session: &NSDraggingSession, _context: NSDraggingContext) -> NSDragOperation {
|
||||
session.setAnimatesToStartingPositionsOnCancelOrFail(true);
|
||||
NSDragOperation::Copy
|
||||
}
|
||||
|
||||
#[unsafe(method(draggingSession:endedAtPoint:operation:))]
|
||||
fn ended(&self, _session: &NSDraggingSession, _point: NSPoint, operation: NSDragOperation) {
|
||||
if let Some(done) = self.ivars().done.take() {
|
||||
done(if operation == NSDragOperation::None { Outcome::Cancelled } else { Outcome::Dropped });
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
impl DragSource {
|
||||
fn new(done: Done, mtm: MainThreadMarker) -> Retained<Self> {
|
||||
let this = Self::alloc(mtm).set_ivars(Ivars { done: Cell::new(Some(done)) });
|
||||
unsafe { msg_send![super(this), init] }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
//! OS file drags out of an app window: the app the files are dropped on (Explorer,
|
||||
//! Finder, a file manager, an SFTP client such as Xftp) copies them, as when they are
|
||||
//! dragged from IDEA's Project view (#2867).
|
||||
//!
|
||||
//! Linux starts a GTK drag offering `text/uri-list`, Windows an OLE `DoDragDrop` of a
|
||||
//! `CF_HDROP` data object, macOS an AppKit dragging session of file URLs. A drag is
|
||||
//! always a copy, never a move, so no target can take project files away.
|
||||
//!
|
||||
//! [`start`] runs on the UI thread while the primary button is still held. It returns
|
||||
//! once the drag has begun (Linux, macOS) or ended (Windows); `done` gets the outcome
|
||||
//! when it ends, or is dropped without being called when the backend lost track of it.
|
||||
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// How a drag ended.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Outcome {
|
||||
/// A target accepted the drop.
|
||||
Dropped,
|
||||
/// Released where nothing accepted it, or cancelled with Escape.
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
/// The paths a drag may carry: at least one, each an absolute path to a file or folder
|
||||
/// on this machine. A remote project's paths name files on its server and fail here.
|
||||
/// Windows also refuses paths of `MAX_PATH` or more: Explorer can't copy from them.
|
||||
/// Network shares (`\\server\share\…`) are local paths here and drag like any other.
|
||||
pub fn local_paths<S: Into<PathBuf>>(paths: impl IntoIterator<Item = S>) -> io::Result<Vec<PathBuf>> {
|
||||
let paths: Vec<PathBuf> = paths.into_iter().map(Into::into).collect();
|
||||
if paths.is_empty() {
|
||||
return Err(io::Error::new(io::ErrorKind::InvalidInput, "no files to drag"));
|
||||
}
|
||||
for path in &paths {
|
||||
if !path.is_absolute() || std::fs::symlink_metadata(path).is_err() {
|
||||
return Err(io::Error::new(io::ErrorKind::NotFound, format!("not a local file: {}", path.display())));
|
||||
}
|
||||
if cfg!(windows) && !fits_max_path(path) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
format!("path too long to drag: {}", path.display()),
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(paths)
|
||||
}
|
||||
|
||||
/// Whether `path` is shorter than Windows' `MAX_PATH` (260 UTF-16 units with the NUL).
|
||||
fn fits_max_path(path: &std::path::Path) -> bool {
|
||||
path.as_os_str().to_string_lossy().encode_utf16().count() < 260
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
pub use gtk_impl::start;
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
mod gtk_impl {
|
||||
use super::Outcome;
|
||||
use gtk::glib::{self, SignalHandlerId};
|
||||
use gtk::prelude::*;
|
||||
use gtk::{TargetList, gdk};
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::io;
|
||||
use std::path::PathBuf;
|
||||
use std::rc::Rc;
|
||||
|
||||
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`; `done` runs on
|
||||
/// the UI thread when the drag ends.
|
||||
pub fn start(
|
||||
window: >k::ApplicationWindow,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
// `file://` URIs with every reserved or non-ASCII byte escaped.
|
||||
let uris = paths
|
||||
.iter()
|
||||
.map(|path| glib::filename_to_uri(path, None).map(|uri| uri.to_string()))
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
.map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
|
||||
let targets = TargetList::new(&[]);
|
||||
targets.add_uri_targets(0);
|
||||
// The button that started the drag (1), not its mask: GTK ends the drag on that
|
||||
// button's release.
|
||||
let context = window
|
||||
.drag_begin_with_coordinates(&targets, gdk::DragAction::COPY, 1, None, -1, -1)
|
||||
.ok_or_else(|| io::Error::other("the window system refused to start a drag"))?;
|
||||
|
||||
let outcome = Rc::new(Cell::new(Outcome::Cancelled));
|
||||
context.connect_drop_performed({
|
||||
let outcome = outcome.clone();
|
||||
move |_, _| outcome.set(Outcome::Dropped)
|
||||
});
|
||||
let handlers: Rc<RefCell<Vec<SignalHandlerId>>> = Rc::default();
|
||||
let data = window.connect_drag_data_get({
|
||||
let context = context.clone();
|
||||
move |_, ctx, selection, _, _| {
|
||||
if *ctx == context {
|
||||
let uris: Vec<&str> = uris.iter().map(String::as_str).collect();
|
||||
selection.set_uris(&uris);
|
||||
}
|
||||
}
|
||||
});
|
||||
// The target asks for the data after the drop (XDND is asynchronous), so the data
|
||||
// handler stays connected until `drag-end`, which GTK emits last.
|
||||
let done = Cell::new(Some(done));
|
||||
let end = window.connect_drag_end({
|
||||
let handlers = handlers.clone();
|
||||
move |window, ctx| {
|
||||
if *ctx != context {
|
||||
return;
|
||||
}
|
||||
for handler in handlers.borrow_mut().drain(..) {
|
||||
window.disconnect(handler);
|
||||
}
|
||||
if let Some(done) = done.take() {
|
||||
done(outcome.get());
|
||||
}
|
||||
}
|
||||
});
|
||||
handlers.borrow_mut().extend([data, end]);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
mod ole;
|
||||
#[cfg(windows)]
|
||||
pub use ole::start;
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
mod appkit;
|
||||
#[cfg(target_os = "macos")]
|
||||
pub use appkit::start;
|
||||
|
||||
/// The `CF_HDROP` file list: each path in UTF-16 with `/` as `\\`, NUL-terminated, and a
|
||||
/// second NUL after the last.
|
||||
#[cfg(any(windows, test))]
|
||||
fn hdrop_file_list<P: IntoIterator<Item = u16>>(paths: impl IntoIterator<Item = P>) -> Vec<u16> {
|
||||
let mut list = Vec::new();
|
||||
for path in paths {
|
||||
list.extend(path.into_iter().map(|unit| if unit == u16::from(b'/') { u16::from(b'\\') } else { unit }));
|
||||
list.push(0);
|
||||
}
|
||||
list.push(0);
|
||||
list
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn accepts_existing_absolute_files_and_folders() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a b ü.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
let paths = local_paths([file.clone(), dir.path().to_path_buf()]).unwrap();
|
||||
assert_eq!(paths, vec![file, dir.path().to_path_buf()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn measures_max_path_in_utf16_units() {
|
||||
let path = |len: usize| PathBuf::from(format!("C:/{}", "中".repeat(len - 3)));
|
||||
assert!(fits_max_path(&path(259)));
|
||||
assert!(!fits_max_path(&path(260)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lists_hdrop_files_double_nul_terminated() {
|
||||
let list = hdrop_file_list(["C:/a b/ü.txt", r"\\nas\share\中"].map(str::encode_utf16));
|
||||
let expected: Vec<u16> = "C:\\a b\\ü.txt\0\\\\nas\\share\\中\0\0".encode_utf16().collect();
|
||||
assert_eq!(list, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_an_empty_drag() {
|
||||
assert_eq!(local_paths(Vec::<PathBuf>::new()).unwrap_err().kind(), io::ErrorKind::InvalidInput);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_relative_and_missing_paths() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let file = dir.path().join("a.txt");
|
||||
std::fs::write(&file, "x").unwrap();
|
||||
// One path that is not local fails the whole drag: none of it is half-copied.
|
||||
for bad in [PathBuf::from("a.txt"), dir.path().join("missing.txt")] {
|
||||
assert_eq!(local_paths([file.clone(), bad]).unwrap_err().kind(), io::ErrorKind::NotFound);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
//! Windows: OLE `DoDragDrop` of a data object that serves the paths as `CF_HDROP`.
|
||||
|
||||
use super::{Outcome, hdrop_file_list};
|
||||
use raw_window_handle::HasWindowHandle;
|
||||
use std::io;
|
||||
use std::os::windows::ffi::OsStrExt;
|
||||
use std::path::PathBuf;
|
||||
use windows::Win32::Foundation::{
|
||||
DRAGDROP_S_CANCEL, DRAGDROP_S_DROP, DRAGDROP_S_USEDEFAULTCURSORS, DV_E_FORMATETC, E_NOTIMPL, GlobalFree, HGLOBAL,
|
||||
OLE_E_ADVISENOTSUPPORTED, S_OK,
|
||||
};
|
||||
use windows::Win32::System::Com::{
|
||||
DATADIR_GET, DVASPECT_CONTENT, FORMATETC, IAdviseSink, IDataObject, IDataObject_Impl, IEnumFORMATETC,
|
||||
IEnumSTATDATA, STGMEDIUM, STGMEDIUM_0, TYMED_HGLOBAL,
|
||||
};
|
||||
use windows::Win32::System::Memory::{GHND, GlobalAlloc, GlobalLock, GlobalUnlock};
|
||||
use windows::Win32::System::Ole::{
|
||||
CF_HDROP, DROPEFFECT, DROPEFFECT_COPY, DROPEFFECT_NONE, DoDragDrop, IDropSource, IDropSource_Impl, OleInitialize,
|
||||
OleUninitialize,
|
||||
};
|
||||
use windows::Win32::System::SystemServices::{MK_LBUTTON, MODIFIERKEYS_FLAGS};
|
||||
use windows::Win32::UI::Shell::{DROPFILES, SHCreateDataObject, SHCreateStdEnumFmtEtc};
|
||||
use windows::core::{BOOL, Error, HRESULT, Ref, Result, implement};
|
||||
|
||||
/// Drags `paths` (see [`super::local_paths`]) until the button is released, then calls
|
||||
/// `done` and returns. `DoDragDrop` runs its own message loop, so the window keeps painting.
|
||||
pub fn start<W: HasWindowHandle>(
|
||||
_window: &W,
|
||||
paths: Vec<PathBuf>,
|
||||
done: impl FnOnce(Outcome) + 'static,
|
||||
) -> io::Result<()> {
|
||||
let files = hdrop_file_list(paths.iter().map(|path| path.as_os_str().encode_wide()));
|
||||
// The window's event loop has initialised OLE on this thread already; this takes a
|
||||
// reference that `OleUninitialize` gives back.
|
||||
unsafe { OleInitialize(None) }.map_err(io::Error::other)?;
|
||||
let outcome = drag(files);
|
||||
unsafe { OleUninitialize() };
|
||||
done(outcome.map_err(io::Error::other)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn drag(files: Vec<u16>) -> Result<Outcome> {
|
||||
// Formats other than `CF_HDROP` (the drag image, drop descriptions the shell sets on
|
||||
// the source's data object) are kept by a plain shell data object.
|
||||
let inner: IDataObject = unsafe { SHCreateDataObject(None, None, None::<&IDataObject>) }?;
|
||||
let data: IDataObject = DataObject { files, inner }.into();
|
||||
let source: IDropSource = DropSource.into();
|
||||
let mut effect = DROPEFFECT_NONE;
|
||||
match unsafe { DoDragDrop(&data, &source, DROPEFFECT_COPY, &mut effect) } {
|
||||
DRAGDROP_S_DROP if effect != DROPEFFECT_NONE => Ok(Outcome::Dropped),
|
||||
DRAGDROP_S_DROP | DRAGDROP_S_CANCEL => Ok(Outcome::Cancelled),
|
||||
error => Err(Error::from_hresult(error)),
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDropSource)]
|
||||
struct DropSource;
|
||||
|
||||
impl IDropSource_Impl for DropSource_Impl {
|
||||
fn QueryContinueDrag(&self, escape_pressed: BOOL, keys: MODIFIERKEYS_FLAGS) -> HRESULT {
|
||||
if escape_pressed.as_bool() {
|
||||
DRAGDROP_S_CANCEL
|
||||
} else if keys & MK_LBUTTON == MODIFIERKEYS_FLAGS(0) {
|
||||
DRAGDROP_S_DROP
|
||||
} else {
|
||||
S_OK
|
||||
}
|
||||
}
|
||||
|
||||
fn GiveFeedback(&self, _effect: DROPEFFECT) -> HRESULT {
|
||||
DRAGDROP_S_USEDEFAULTCURSORS
|
||||
}
|
||||
}
|
||||
|
||||
#[implement(IDataObject)]
|
||||
struct DataObject {
|
||||
/// The `DROPFILES` file list ([`hdrop_file_list`]).
|
||||
files: Vec<u16>,
|
||||
inner: IDataObject,
|
||||
}
|
||||
|
||||
const HDROP: FORMATETC = FORMATETC {
|
||||
cfFormat: CF_HDROP.0,
|
||||
ptd: std::ptr::null_mut(),
|
||||
dwAspect: DVASPECT_CONTENT.0,
|
||||
lindex: -1,
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
};
|
||||
|
||||
fn is_hdrop(format: *const FORMATETC) -> bool {
|
||||
unsafe { format.as_ref() }.is_some_and(|format| {
|
||||
format.cfFormat == HDROP.cfFormat && format.dwAspect == HDROP.dwAspect && format.tymed & HDROP.tymed != 0
|
||||
})
|
||||
}
|
||||
|
||||
impl DataObject {
|
||||
/// A new `DROPFILES` block; the receiver frees it.
|
||||
fn hdrop(&self) -> Result<HGLOBAL> {
|
||||
let header = size_of::<DROPFILES>();
|
||||
let size = header + std::mem::size_of_val(self.files.as_slice());
|
||||
unsafe {
|
||||
let handle = GlobalAlloc(GHND, size)?;
|
||||
let block = GlobalLock(handle).cast::<u8>();
|
||||
if block.is_null() {
|
||||
let error = Error::from_thread();
|
||||
let _ = GlobalFree(Some(handle));
|
||||
return Err(error);
|
||||
}
|
||||
block.cast::<DROPFILES>().write_unaligned(DROPFILES {
|
||||
pFiles: header as u32,
|
||||
fWide: true.into(),
|
||||
..Default::default()
|
||||
});
|
||||
std::ptr::copy_nonoverlapping(self.files.as_ptr().cast::<u8>(), block.add(header), size - header);
|
||||
// Fails with no error once the lock count is back to zero, which it is.
|
||||
let _ = GlobalUnlock(handle);
|
||||
Ok(handle)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl IDataObject_Impl for DataObject_Impl {
|
||||
fn GetData(&self, format: *const FORMATETC) -> Result<STGMEDIUM> {
|
||||
if !is_hdrop(format) {
|
||||
return unsafe { self.inner.GetData(format) };
|
||||
}
|
||||
Ok(STGMEDIUM {
|
||||
tymed: TYMED_HGLOBAL.0 as u32,
|
||||
u: STGMEDIUM_0 { hGlobal: self.hdrop()? },
|
||||
pUnkForRelease: std::mem::ManuallyDrop::new(None),
|
||||
})
|
||||
}
|
||||
|
||||
fn GetDataHere(&self, format: *const FORMATETC, medium: *mut STGMEDIUM) -> Result<()> {
|
||||
if is_hdrop(format) {
|
||||
return Err(DV_E_FORMATETC.into());
|
||||
}
|
||||
unsafe { self.inner.GetDataHere(format, medium) }
|
||||
}
|
||||
|
||||
fn QueryGetData(&self, format: *const FORMATETC) -> HRESULT {
|
||||
if is_hdrop(format) { S_OK } else { unsafe { self.inner.QueryGetData(format) } }
|
||||
}
|
||||
|
||||
fn GetCanonicalFormatEtc(&self, format: *const FORMATETC, canonical: *mut FORMATETC) -> HRESULT {
|
||||
unsafe { self.inner.GetCanonicalFormatEtc(format, canonical) }
|
||||
}
|
||||
|
||||
fn SetData(&self, format: *const FORMATETC, medium: *const STGMEDIUM, release: BOOL) -> Result<()> {
|
||||
unsafe { self.inner.SetData(format, medium, release.as_bool()) }
|
||||
}
|
||||
|
||||
fn EnumFormatEtc(&self, direction: u32) -> Result<IEnumFORMATETC> {
|
||||
if direction != DATADIR_GET.0 as u32 {
|
||||
return Err(E_NOTIMPL.into());
|
||||
}
|
||||
unsafe { SHCreateStdEnumFmtEtc(&[HDROP]) }
|
||||
}
|
||||
|
||||
fn DAdvise(&self, _format: *const FORMATETC, _advf: u32, _sink: Ref<IAdviseSink>) -> Result<u32> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn DUnadvise(&self, _connection: u32) -> Result<()> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
|
||||
fn EnumDAdvise(&self) -> Result<IEnumSTATDATA> {
|
||||
Err(OLE_E_ADVISENOTSUPPORTED.into())
|
||||
}
|
||||
}
|
||||
@@ -5,10 +5,10 @@ use crate::Host;
|
||||
use crate::agent_secrets::{AgentSecrets, Kept};
|
||||
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, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput,
|
||||
McpTransport, NewAgentTask,
|
||||
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCliOffer,
|
||||
AgentCliUpdateResult, AgentCommand, AgentContextUsage, AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe,
|
||||
AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput, ExternalSession, McpExternalSource,
|
||||
McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput, McpTransport, NewAgentTask,
|
||||
};
|
||||
use ide_command::command;
|
||||
use ide_core::error::ErrorKind;
|
||||
@@ -17,12 +17,28 @@ use ide_tools::InstallEvent;
|
||||
use std::collections::HashSet;
|
||||
use std::sync::{LazyLock, Mutex};
|
||||
|
||||
/// Streams the project's agent events to this window; returns every task.
|
||||
/// Streams the project's agent events to `subscriber`, one of the project's windows (a remote
|
||||
/// host sees them all as one `window`); returns every task.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_subscribe(host: &Host, window: &str, on_event: Channel<AgentEvent>) -> IdeResult<Vec<AgentTask>> {
|
||||
Ok(host.project(window)?.agents.subscribe(std::sync::Arc::new(move |e| {
|
||||
let _ = on_event.send(e);
|
||||
})))
|
||||
pub fn agent_subscribe(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
on_event: Channel<AgentEvent>,
|
||||
subscriber: String,
|
||||
) -> IdeResult<Vec<AgentTask>> {
|
||||
Ok(host.project(window)?.agents.subscribe_as(
|
||||
&subscriber,
|
||||
std::sync::Arc::new(move |e| {
|
||||
let _ = on_event.send(e);
|
||||
}),
|
||||
))
|
||||
}
|
||||
|
||||
/// Stops the events of a window that closed.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_unsubscribe(host: &Host, window: &str, subscriber: String) -> IdeResult<()> {
|
||||
host.project(window)?.agents.unsubscribe(&subscriber);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[command(trust = trusted)]
|
||||
@@ -33,6 +49,16 @@ pub fn agent_providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider
|
||||
Ok(providers)
|
||||
}
|
||||
|
||||
/// Hermes Agent profiles on this machine (`default` first); empty without Hermes.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_hermes_profiles(host: &Host, window: &str) -> IdeResult<Vec<ide_agent::hermes::HermesProfile>> {
|
||||
host.require_trust(window)?;
|
||||
let root = ide_agent::hermes::root(dirs::home_dir().as_deref());
|
||||
tokio::task::spawn_blocking(move || root.map(|r| ide_agent::hermes::labeled_profiles(&r)).unwrap_or_default())
|
||||
.await
|
||||
.map_err(join_err)
|
||||
}
|
||||
|
||||
/// Refreshes the model catalog; force bypasses freshness, not the cooldown.
|
||||
#[command(trust = trusted)]
|
||||
pub fn agent_refresh_models(
|
||||
@@ -333,6 +359,50 @@ pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32)
|
||||
host.project(window)?.agents.rollback(&task, turns).await
|
||||
}
|
||||
|
||||
/// Checks the selected installation without modifying it.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_cli_update_check(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
cli_update(host, window, provider, None, request).await
|
||||
}
|
||||
|
||||
/// Installs the exact version offered if the selected installation still matches.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_cli_update(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
offer: AgentCliOffer,
|
||||
request: RequestId,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
cli_update(host, window, provider, Some(offer), request).await
|
||||
}
|
||||
|
||||
async fn cli_update(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
offer: Option<AgentCliOffer>,
|
||||
request: RequestId,
|
||||
) -> IdeResult<AgentCliUpdateResult> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
let installing = offer.as_ref().map(|_| Installing::begin(&provider)).transpose()?;
|
||||
let cancel = host.begin_project_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
let _installing = installing;
|
||||
project.agents.cli_update(&provider, offer.as_ref(), &cancel)
|
||||
})
|
||||
.await
|
||||
.map_err(join_err);
|
||||
host.end_request(request);
|
||||
result?
|
||||
}
|
||||
|
||||
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
|
||||
/// or sign-in run). Remembered until `refresh`.
|
||||
#[command(trust = trusted)]
|
||||
@@ -341,6 +411,13 @@ pub async fn agent_probe(host: &Host, window: &str, provider: String, refresh: b
|
||||
host.project(window)?.agents.probe(&provider, refresh).await
|
||||
}
|
||||
|
||||
/// Reads the running session's context categories without sending a prompt.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn agent_context_usage(host: &Host, window: &str, task: String) -> IdeResult<AgentContextUsage> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.context_usage(&task).await
|
||||
}
|
||||
|
||||
/// Stops the task's current turn, or with `subagent` only that subagent's work.
|
||||
#[command(trust = always)]
|
||||
pub fn agent_cancel(host: &Host, window: &str, task: String, subagent: Option<String>) -> IdeResult<()> {
|
||||
@@ -1067,7 +1144,10 @@ ide_command::domain!(
|
||||
agent_archive,
|
||||
agent_base_text,
|
||||
agent_cancel,
|
||||
agent_context_usage,
|
||||
agent_changes,
|
||||
agent_cli_update,
|
||||
agent_cli_update_check,
|
||||
agent_commands,
|
||||
agent_create,
|
||||
agent_delete,
|
||||
@@ -1075,6 +1155,7 @@ ide_command::domain!(
|
||||
agent_external_sessions,
|
||||
agent_fork,
|
||||
agent_grouped_changes,
|
||||
agent_hermes_profiles,
|
||||
agent_import_session,
|
||||
agent_mcp_discover_sources,
|
||||
agent_mcp_import,
|
||||
@@ -1106,4 +1187,5 @@ ide_command::domain!(
|
||||
agent_subscribe,
|
||||
agent_unarchive,
|
||||
agent_unqueue,
|
||||
agent_unsubscribe,
|
||||
);
|
||||
@@ -1,6 +1,7 @@
|
||||
//! 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
|
||||
//! `@Given("…")` annotations and Java 8 lambdas) and Python files (behave and pytest-bdd's
|
||||
//! `@given('…')` decorators) 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.
|
||||
|
||||
@@ -21,6 +22,8 @@ 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("];
|
||||
/** What a Python step decorator starts with (behave also takes the capitalized names). */
|
||||
const PYTHON_STEP_CALLS: [&str; 8] = ["@given(", "@when(", "@then(", "@step(", "@Given(", "@When(", "@Then(", "@Step("];
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -38,10 +41,14 @@ fn is_feature(path: &Path) -> bool {
|
||||
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")
|
||||
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt" | "py")
|
||||
)
|
||||
}
|
||||
|
||||
fn is_python(path: &Path) -> bool {
|
||||
path.extension().and_then(|e| e.to_str()) == Some("py")
|
||||
}
|
||||
|
||||
/// 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());
|
||||
@@ -55,7 +62,8 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
|
||||
return;
|
||||
}
|
||||
let Ok(text) = std::fs::read_to_string(path) else { return };
|
||||
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
|
||||
let calls: &[&str] = if is_python(path) { &PYTHON_STEP_CALLS } else { &STEP_CALLS };
|
||||
if !feature && !calls.iter().any(|call| text.contains(call)) {
|
||||
return;
|
||||
}
|
||||
let Ok(mut found) = found.lock() else { return };
|
||||
@@ -76,6 +84,7 @@ pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>>
|
||||
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());
|
||||
excludes.push("site-packages".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));
|
||||
@@ -104,11 +113,23 @@ mod tests {
|
||||
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("steps/cart_steps.py"), "@given('an empty cart')\ndef step_impl(context): pass")
|
||||
.unwrap();
|
||||
std::fs::write(root.join("src/util.py"), "def given(x): return x\nWhen = 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_eq!(
|
||||
names,
|
||||
[
|
||||
"features/cart.feature",
|
||||
"src/CartSteps.java",
|
||||
"steps/bdd.mjs",
|
||||
"steps/cart.steps.ts",
|
||||
"steps/cart_steps.py"
|
||||
]
|
||||
);
|
||||
assert!(files[0].feature && !files[1].feature);
|
||||
assert!(files[3].text.contains("an empty cart"));
|
||||
}
|
||||
|
||||
@@ -8,30 +8,79 @@ use crate::{Host, Project};
|
||||
use ide_command::command;
|
||||
|
||||
use ide_build::compile::{self, BuildEvent, BuildKind, BuildResult};
|
||||
use ide_build::maven::PomGoto;
|
||||
use ide_build::maven::completion::{PomCompletion, PomCompletionOption};
|
||||
use ide_build::maven::{PomGoto, PomManagedDeclaration, PomNavigationOptions};
|
||||
use ide_build::pom_edit::{ArtifactKey, Exclusion};
|
||||
use ide_build::{BuildModel, BuildTool, SyncOptions, SyncProgress};
|
||||
use ide_core::settings::Settings;
|
||||
use ide_core::{DocId, FileEdit, IdeError, IdeEvent, IdeResult, Location, Pos, Range, RequestId, WorkspaceEdit};
|
||||
use std::collections::HashMap;
|
||||
use std::path::Path;
|
||||
use std::sync::Arc;
|
||||
use std::sync::{Arc, Mutex, OnceLock};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
fn join_err(e: tokio::task::JoinError) -> IdeError {
|
||||
IdeError::internal(e.to_string())
|
||||
}
|
||||
|
||||
/// POM gutters in several editors refresh together. A very short cache lets those
|
||||
/// requests share one reactor scan without serving a stale module list after edits settle.
|
||||
const MAVEN_MODULE_CACHE_TTL: Duration = Duration::from_millis(250);
|
||||
type MavenModuleCache = HashMap<String, (Instant, Vec<ide_build::maven::ModulePom>)>;
|
||||
static MAVEN_MODULES: OnceLock<Mutex<MavenModuleCache>> = OnceLock::new();
|
||||
|
||||
fn maven_modules(
|
||||
project: &Project,
|
||||
settings: &Settings,
|
||||
options: &PomNavigationOptions,
|
||||
) -> Vec<ide_build::maven::ModulePom> {
|
||||
let key = format!(
|
||||
"{}\0{:?}\0{:?}\0{:?}\0{:?}",
|
||||
project.root.display(),
|
||||
project.build_cache_dir(),
|
||||
settings.languages.java.maven.linked_projects,
|
||||
options.profiles,
|
||||
options.jdk_version
|
||||
);
|
||||
let cache = MAVEN_MODULES.get_or_init(|| Mutex::new(HashMap::new()));
|
||||
if let Some((_at, modules)) = cache.lock().ok().and_then(|mut cache| {
|
||||
let fresh = cache.get(&key).filter(|(at, _)| at.elapsed() < MAVEN_MODULE_CACHE_TTL).cloned();
|
||||
if fresh.is_none() {
|
||||
cache.remove(&key);
|
||||
}
|
||||
fresh
|
||||
}) {
|
||||
return modules;
|
||||
}
|
||||
let model = load(&project.root, &project.build_cache_dir(), settings).maven.unwrap_or_default();
|
||||
let modules = model
|
||||
.projects
|
||||
.into_iter()
|
||||
.map(|p| ide_build::maven::ModulePom {
|
||||
group_id: p.group_id,
|
||||
artifact_id: p.artifact_id,
|
||||
version: p.version,
|
||||
pom: project.root.join(&p.pom),
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
if let Ok(mut cache) = cache.lock() {
|
||||
cache.insert(key, (Instant::now(), modules.clone()));
|
||||
}
|
||||
modules
|
||||
}
|
||||
|
||||
/// The build model with the launch settings applied: the JDK (`JAVA_HOME`), and
|
||||
/// the Maven home and options from Settings › Maven.
|
||||
pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
|
||||
let mut model = ide_build::load_linked(
|
||||
let jdk = ide_sdk::apply::project_jdk(root, settings);
|
||||
let mut model = ide_build::load_linked_with_jdk(
|
||||
root,
|
||||
cache,
|
||||
ide_sdk::apply::maven_local_repository(root, settings),
|
||||
&settings.languages.java.maven,
|
||||
&settings.languages.java.gradle,
|
||||
ide_sdk::apply::maven_jdk(root, settings, None).map(|jdk| jdk.major),
|
||||
);
|
||||
let jdk = ide_sdk::apply::project_jdk(root, settings);
|
||||
if let Some(m) = &mut model.maven {
|
||||
let mvn = ide_sdk::apply::maven_command(root, settings);
|
||||
let options = ide_sdk::apply::maven_options(root, settings);
|
||||
@@ -77,6 +126,23 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {
|
||||
model
|
||||
}
|
||||
|
||||
/// POM navigation follows the same profile choices as the last Maven sync and
|
||||
/// resolves JDK-activated profiles with the project's selected Maven runtime.
|
||||
fn pom_navigation_options(project: &Project, settings: &Settings) -> PomNavigationOptions {
|
||||
let mut profiles = settings.languages.java.maven.profiles(&[]);
|
||||
for profile in ide_build::maven_profiles(&project.build_cache_dir()) {
|
||||
if !profiles.contains(&profile) {
|
||||
profiles.push(profile);
|
||||
}
|
||||
}
|
||||
PomNavigationOptions {
|
||||
local_repo: ide_sdk::apply::maven_local_repository(&project.root, settings)
|
||||
.or_else(ide_build::maven::default_local_repo),
|
||||
profiles,
|
||||
jdk_version: ide_sdk::apply::maven_jdk(&project.root, settings, None).map(|jdk| jdk.major),
|
||||
}
|
||||
}
|
||||
|
||||
/// Build and Run use the same selected toolchain and module-local runtime discovery.
|
||||
fn prepare_plan(mut plan: compile::BuildPlan, root: &Path, settings: &Settings) -> compile::BuildPlan {
|
||||
let kind = match plan.system {
|
||||
@@ -547,8 +613,9 @@ pub async fn maven_dependency_declaration(
|
||||
}
|
||||
|
||||
/// The go-to-declaration target at `pos` of a Maven POM: the definition of the
|
||||
/// `${property}` at the caret, or the `<dependencyManagement>` / `<pluginManagement>`
|
||||
/// entry providing the dependency's / plugin's version, along the parent chain.
|
||||
/// `${property}` at the caret, the parent POM, or the dependency / plugin's own POM
|
||||
/// (a project module first, then the local repository). A dependency without a
|
||||
/// resolvable artifact POM falls back to its management entry.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos: Pos) -> IdeResult<Option<PomGoto>> {
|
||||
// `pom` is project-relative, or absolute for a parent POM opened from the local repository.
|
||||
@@ -561,26 +628,55 @@ pub async fn maven_goto_declaration(host: &Host, window: &str, pom: String, pos:
|
||||
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
|
||||
let text = project.text_of(&path)?;
|
||||
let settings = project.settings.effective();
|
||||
let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings)
|
||||
.or_else(ide_build::maven::default_local_repo);
|
||||
let modules = || {
|
||||
let model = load(&project.root, &project.build_cache_dir(), &settings).maven.unwrap_or_default();
|
||||
model
|
||||
.projects
|
||||
.into_iter()
|
||||
.map(|p| ide_build::maven::ModulePom {
|
||||
group_id: p.group_id,
|
||||
artifact_id: p.artifact_id,
|
||||
pom: project.root.join(&p.pom),
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
Ok(ide_build::maven::goto_declaration_in(&text, &path, pos, repo, modules))
|
||||
let options = pom_navigation_options(&project, &settings);
|
||||
let module_options = options.clone();
|
||||
let modules = || maven_modules(&project, &settings, &module_options);
|
||||
Ok(ide_build::maven::goto_declaration_with(&text, &path, pos, options, modules))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// Gutter targets of the unversioned dependencies and plugins in a Maven POM:
|
||||
/// the management declarations that actually supply their versions, including
|
||||
/// parent POMs and imported BOMs. Cancel with `cancel_request(request)`.
|
||||
#[command(trust = trusted)]
|
||||
pub async fn maven_managed_declarations(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
pom: String,
|
||||
request: RequestId,
|
||||
) -> IdeResult<Vec<PomManagedDeclaration>> {
|
||||
let project = host.project(window)?;
|
||||
let cancel = host.begin_project_read_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let given = Path::new(&pom);
|
||||
let path = if given.is_absolute() { given.to_path_buf() } else { project.root.join(given) };
|
||||
let text = project.text_of(&path)?;
|
||||
let settings = project.settings.effective();
|
||||
let options = pom_navigation_options(&project, &settings);
|
||||
let cancelled = cancel.clone();
|
||||
let module_options = options.clone();
|
||||
let modules = || {
|
||||
if cancelled.is_cancelled() {
|
||||
return Vec::new();
|
||||
}
|
||||
maven_modules(&project, &settings, &module_options)
|
||||
};
|
||||
let declarations = ide_build::maven::managed_declarations_with(&text, &path, options, modules);
|
||||
if cancel.is_cancelled() { Err(IdeError::cancelled()) } else { Ok(declarations) }
|
||||
})
|
||||
.await;
|
||||
host.end_request(request);
|
||||
match result {
|
||||
Ok(result) => result,
|
||||
Err(error) => Err(join_err(error)),
|
||||
}
|
||||
}
|
||||
|
||||
/// How long completion waits for Maven Central before answering from the local repository.
|
||||
const CENTRAL_WAIT: std::time::Duration = std::time::Duration::from_secs(1);
|
||||
|
||||
@@ -1333,4 +1429,5 @@ ide_command::domain!(
|
||||
maven_dependency_declaration,
|
||||
maven_exclude_dependency,
|
||||
maven_goto_declaration,
|
||||
maven_managed_declarations,
|
||||
);
|
||||
@@ -70,6 +70,13 @@ pub async fn doc_save(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
host.debugger.refresh_source_mirrors(host.owner_window(window)).await
|
||||
}
|
||||
|
||||
/// Load Changes from Disk: discards the buffer's unsaved changes and reads its file again.
|
||||
#[command(trust = always)]
|
||||
pub async fn doc_reload_from_disk(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
|
||||
let project = host.project(window)?;
|
||||
host.blocking(move || project.documents.discard_and_reload(doc)).await
|
||||
}
|
||||
|
||||
/// An automatic save: `false` (nothing written) when the file changed on disk after the
|
||||
/// buffer was edited, which only an explicit save overwrites.
|
||||
#[command(trust = always)]
|
||||
@@ -120,6 +127,7 @@ ide_command::domain!(
|
||||
doc_edit,
|
||||
doc_open,
|
||||
doc_open_untitled,
|
||||
doc_reload_from_disk,
|
||||
doc_save,
|
||||
doc_autosave,
|
||||
doc_save_all,
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use super::*;
|
||||
use crate::{HostConfig, Project};
|
||||
use ide_core::{IdeEvent, TextChange, event::NotifyLevel};
|
||||
use ide_core::{IdeEvent, TextChange};
|
||||
use parking_lot::Mutex;
|
||||
use std::{path::Path, sync::Arc};
|
||||
|
||||
@@ -57,7 +57,9 @@ impl Fixture {
|
||||
self.events
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|e| matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::Notify { .. }))
|
||||
.filter(|e| {
|
||||
matches!(e, IdeEvent::DocPatched { .. } | IdeEvent::DocDirty { .. } | IdeEvent::DocDiskConflict { .. })
|
||||
})
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
@@ -110,7 +112,7 @@ async fn dirty_document_keeps_edits_and_warns_once() {
|
||||
let loaded = f.project.documents.snapshot(original.id).unwrap();
|
||||
assert_eq!(loaded.text, "local original\n");
|
||||
assert!(loaded.dirty);
|
||||
assert!(matches!(f.document_events().as_slice(), [IdeEvent::Notify { level: NotifyLevel::Warning, .. }]));
|
||||
assert!(matches!(f.document_events().as_slice(), [IdeEvent::DocDiskConflict { .. }]));
|
||||
f.events.lock().clear();
|
||||
f.sync().await;
|
||||
assert!(f.document_events().is_empty());
|
||||
|
||||
@@ -122,28 +122,38 @@ pub async fn sdk_python_interpreter(host: &Host, window: &str, path: PathBuf) ->
|
||||
|
||||
/// The interpreter the project uses: the configured one, else its virtualenv.
|
||||
#[command(trust = trusted)]
|
||||
pub fn sdk_python_effective(host: &Host, window: &str, near: Option<PathBuf>) -> IdeResult<Option<ide_core::IpcPath>> {
|
||||
pub async fn sdk_python_effective(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
near: Option<PathBuf>,
|
||||
) -> IdeResult<Option<ide_core::IpcPath>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
let member = ide_workspace::workspace::Workspace::load(&project.root)?.and_then(|w| {
|
||||
let near = near.as_deref()?;
|
||||
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
|
||||
});
|
||||
let (root, settings) = match member {
|
||||
Some(root) => {
|
||||
let settings = ide_workspace::SettingsStore::load(&host.config_dir, Some(&root)).effective();
|
||||
(root, settings)
|
||||
}
|
||||
None => (project.root.clone(), project.settings.effective()),
|
||||
};
|
||||
// A member with no Python of its own falls back to the primary project's
|
||||
// (the same chain run configurations use), so every answer names one interpreter.
|
||||
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
|
||||
(root != project.root)
|
||||
.then(|| ide_sdk::apply::python_interpreter(&project.root, &project.settings.effective()))
|
||||
.flatten()
|
||||
});
|
||||
Ok(interpreter.map(Into::into))
|
||||
let (config_dir, project_root) = (host.config_dir.clone(), project.root.clone());
|
||||
// Loading a member's settings needs more stack than a sync command's main thread has left.
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let member = ide_workspace::workspace::Workspace::load(&project_root).ok().flatten().and_then(|w| {
|
||||
let near = near.as_deref()?;
|
||||
w.projects.into_iter().filter(|root| near.starts_with(root)).max_by_key(|root| root.components().count())
|
||||
});
|
||||
let (root, settings) = match member {
|
||||
Some(root) => {
|
||||
let settings = ide_workspace::SettingsStore::load(&config_dir, Some(&root)).effective();
|
||||
(root, settings)
|
||||
}
|
||||
None => (project_root.clone(), project.settings.effective()),
|
||||
};
|
||||
// A member with no Python of its own falls back to the primary project's
|
||||
// (the same chain run configurations use), so every answer names one interpreter.
|
||||
let interpreter = ide_sdk::apply::python_interpreter_near(&root, near.as_deref(), &settings).or_else(|| {
|
||||
(root != project_root)
|
||||
.then(|| ide_sdk::apply::python_interpreter(&project_root, &project.settings.effective()))
|
||||
.flatten()
|
||||
});
|
||||
Ok(interpreter.map(Into::into))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// The PHP interpreter chosen in Settings › Languages & Frameworks › PHP; `None`: the `php` on `PATH`.
|
||||
@@ -461,7 +471,7 @@ mod tests {
|
||||
host.open_project("main", &root).unwrap();
|
||||
let detected = sdk_detect(&host, "main", SdkKind::Python).await.unwrap();
|
||||
assert!(detected.iter().any(|s| s.path == sdk.path && s.name == sdk.name));
|
||||
assert_eq!(sdk_python_effective(&host, "main", None).unwrap(), Some(sdk.path));
|
||||
assert_eq!(sdk_python_effective(&host, "main", None).await.unwrap(), Some(sdk.path));
|
||||
assert!(sdk_python_interpreter(&host, "main", root.join("README.md")).await.unwrap().is_none());
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
@@ -633,8 +633,14 @@ pub async fn vcs_add_to_ignore(
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
blocking(move || {
|
||||
// The Changes view lists every repository of the window (the project's and the
|
||||
// attached ones'): a path inside the project folder, or in any of those repositories.
|
||||
// The folder check stays so a request right after opening, before the repositories
|
||||
// are discovered, still works.
|
||||
let repos = project.repos();
|
||||
for path in &paths {
|
||||
if path == &project.root || !path.starts_with(&project.root) {
|
||||
let in_project = path != &project.root && path.starts_with(&project.root);
|
||||
if !in_project && repos.for_path(path).is_none() {
|
||||
return Err(ide_core::IdeError::invalid("Ignore selection is outside the project"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -406,15 +406,16 @@ impl Proc {
|
||||
}
|
||||
}
|
||||
|
||||
/// What it printed since the last call, each stream at most `max` bytes.
|
||||
/// What it printed since the last call, each stream at most `max` bytes. The status
|
||||
/// comes with the last chunk only: once it ended, its pipes reached the end and
|
||||
/// nothing is left to read, so a caller can stop at the first chunk that has one.
|
||||
fn chunk(&self, max: usize) -> ProcessChunk {
|
||||
let mut state = self.state.lock();
|
||||
let eof = state.readers == 0;
|
||||
ProcessChunk {
|
||||
stdout: take_text(&mut state.stdout, max, eof),
|
||||
stderr: take_text(&mut state.stderr, max, eof),
|
||||
status: state.status,
|
||||
}
|
||||
let stdout = take_text(&mut state.stdout, max, eof);
|
||||
let stderr = take_text(&mut state.stderr, max, eof);
|
||||
let drained = eof && state.stdout.is_empty() && state.stderr.is_empty();
|
||||
ProcessChunk { stdout, stderr, status: state.status.filter(|_| drained) }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4126,6 +4127,27 @@ mod tests {
|
||||
api.release_process(id);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn the_status_comes_with_the_last_of_the_output() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let api = shell_api(tmp.path());
|
||||
let token = CancellationToken::new();
|
||||
let id = api.start_process(shell("printf 'abcdefghij'; printf 'xyz' >&2"), None, None).unwrap();
|
||||
let first = api.wait_process(id, 4, Duration::from_secs(5), &token).unwrap();
|
||||
assert_eq!((first.stdout.as_str(), first.stderr.as_str(), first.status), ("abcd", "xyz", None));
|
||||
let mut stdout = first.stdout;
|
||||
let status = loop {
|
||||
let chunk = api.poll_process(id, 4).unwrap();
|
||||
stdout.push_str(&chunk.stdout);
|
||||
if let Some(status) = chunk.status {
|
||||
break status;
|
||||
}
|
||||
};
|
||||
assert_eq!((stdout.as_str(), status), ("abcdefghij", 0));
|
||||
api.release_process(id);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn programs_run_only_as_approved() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -191,6 +191,7 @@ pub fn client_accepts(event: &IdeEvent, trusted: bool) -> bool {
|
||||
| IdeEvent::ExcludedDirsChanged { .. }
|
||||
| IdeEvent::DocPatched { .. }
|
||||
| IdeEvent::DocDirty { .. }
|
||||
| IdeEvent::DocDiskConflict { .. }
|
||||
| IdeEvent::WorkspaceEditApplied { .. }
|
||||
| IdeEvent::DocLanguage { .. }
|
||||
| IdeEvent::Diagnostics { .. }
|
||||
|
||||
@@ -161,7 +161,7 @@ async fn light_notebooks_open_without_interpreter_detection_or_execution() {
|
||||
assert!(ops::notebook::notebook_save(&host, "main", notebook.id.clone()).await.is_ok());
|
||||
let error = ops::sdk::sdk_detect(&host, "main", ide_sdk::SdkKind::Python).await.unwrap_err();
|
||||
assert!(error.message.contains("Restricted Mode"));
|
||||
assert!(ops::sdk::sdk_python_effective(&host, "main", None).is_err());
|
||||
assert!(ops::sdk::sdk_python_effective(&host, "main", None).await.is_err());
|
||||
assert!(ops::sdk::sdk_locate_tools(&host, "main", vec!["prettier".into()], Some(root)).await.is_err());
|
||||
let error = ops::notebook::notebook_restart(&host, "main", notebook.id.clone()).await.unwrap_err();
|
||||
assert!(error.message.contains("Restricted Mode"));
|
||||
|
||||
@@ -351,7 +351,7 @@ async fn python_venv() {
|
||||
// The project's virtualenv: listed first, and the interpreter the project uses.
|
||||
let found = ops::sdk::sdk_detect(&p.host, WINDOW, ide_sdk::SdkKind::Python).await.unwrap();
|
||||
assert_eq!(found.first().map(|s| s.source.as_str()), Some("venv"), "{found:?}");
|
||||
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).unwrap().expect("an interpreter");
|
||||
let effective = ops::sdk::sdk_python_effective(&p.host, WINDOW, None).await.unwrap().expect("an interpreter");
|
||||
assert!(effective.starts_with(p.root.join(".venv")), "{effective:?}");
|
||||
}
|
||||
|
||||
|
||||
@@ -21,6 +21,7 @@ async fn patches_read_and_write_the_requested_repository() {
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
std::fs::write(root.join("same.txt"), format!("root {i}\n")).unwrap();
|
||||
git(root, &["add", "."]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
@@ -65,3 +66,75 @@ async fn patches_read_and_write_the_requested_repository() {
|
||||
assert!(vcs::vcs_apply_patch(&host, "main", Some(base.join("outside")), String::new()).await.is_err());
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
/// The Changes view also lists attached projects' repositories, and their untracked files
|
||||
/// offer Add to .gitignore / .git/info/exclude: the guard must follow the window's
|
||||
/// repository set, not the project folder alone.
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn add_to_ignore_accepts_the_repositories_of_attached_projects() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let project_root = base.join("project");
|
||||
let attached_root = base.join("attached");
|
||||
for root in [&project_root, &attached_root] {
|
||||
std::fs::create_dir_all(root).unwrap();
|
||||
git(root, &["init", "-b", "main"]);
|
||||
git(root, &["config", "user.name", "Test"]);
|
||||
git(root, &["config", "user.email", "[email protected]"]);
|
||||
git(root, &["config", "core.autocrlf", "false"]);
|
||||
std::fs::write(root.join("tracked.txt"), "x\n").unwrap();
|
||||
git(root, &["add", "."]);
|
||||
git(root, &["commit", "-m", "initial"]);
|
||||
}
|
||||
// Untracked files, one per repository; the attached one is what failed.
|
||||
let own = project_root.join("own.ignore-me");
|
||||
let attached = attached_root.join("attached.ignore-me");
|
||||
std::fs::write(&own, "x").unwrap();
|
||||
std::fs::write(&attached, "x").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,
|
||||
});
|
||||
host.trust.decide(&project_root, true, false).unwrap();
|
||||
host.trust.decide(&attached_root, true, false).unwrap();
|
||||
let project = host.open_project("main", &project_root).unwrap();
|
||||
ide_host::ops::project::attach_workspace(&host, "main", &attached_root).unwrap();
|
||||
for _ in 0..500 {
|
||||
if project.repos().all().len() == 2 {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
assert_eq!(project.repos().all().len(), 2);
|
||||
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![attached.clone()], ide_vcs::IgnoreDestination::Gitignore).await.unwrap();
|
||||
assert!(
|
||||
std::fs::read_to_string(attached_root.join(".gitignore")).unwrap().contains("/attached.ignore-me"),
|
||||
"the attached repository's .gitignore did not receive the rule"
|
||||
);
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![own.clone()], ide_vcs::IgnoreDestination::LocalExclude).await.unwrap();
|
||||
assert!(
|
||||
std::fs::read_to_string(project_root.join(".git/info/exclude")).unwrap().contains("/own.ignore-me"),
|
||||
"the project repository's exclude did not receive the rule"
|
||||
);
|
||||
|
||||
// A repository of an unattached sibling folder stays outside.
|
||||
let sibling_root = base.join("sibling");
|
||||
std::fs::create_dir_all(&sibling_root).unwrap();
|
||||
git(&sibling_root, &["init", "-b", "main"]);
|
||||
let sibling = sibling_root.join("sibling.ignore-me");
|
||||
std::fs::write(&sibling, "x").unwrap();
|
||||
let error =
|
||||
vcs::vcs_add_to_ignore(&host, "main", vec![sibling], ide_vcs::IgnoreDestination::Gitignore).await.unwrap_err();
|
||||
assert!(error.message.contains("outside the project"), "{error:?}");
|
||||
assert!(!sibling_root.join(".gitignore").exists());
|
||||
host.close_project("main");
|
||||
}
|
||||
@@ -199,7 +199,9 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
host.trust.decide(&member, true, false).unwrap();
|
||||
host.open_project("main", &primary).unwrap();
|
||||
let python = |near: Option<&std::path::Path>| {
|
||||
ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())).unwrap().map(|p| p.into_path_buf())
|
||||
futures::executor::block_on(ops::sdk::sdk_python_effective(&host, "main", near.map(|p| p.to_path_buf())))
|
||||
.unwrap()
|
||||
.map(|p| p.into_path_buf())
|
||||
};
|
||||
// The primary project's own virtualenv, and the bare member inheriting it.
|
||||
assert_eq!(python(Some(&primary)), Some(venv_python.clone()));
|
||||
@@ -217,6 +219,13 @@ async fn python_effective_interpreter_falls_back_to_the_primary_project() {
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(python(Some(&member.join("src"))), Some(configured));
|
||||
// A workspace file that fails to load (a corrupt one, say) falls back to the
|
||||
// primary project's interpreter instead of failing the whole command.
|
||||
let workspace_file = primary.join(ide_workspace::workspace::FILE);
|
||||
let valid = std::fs::read(&workspace_file).unwrap();
|
||||
std::fs::write(&workspace_file, b"{not json").unwrap();
|
||||
assert_eq!(python(Some(&member.join("src"))), Some(venv_python.clone()));
|
||||
std::fs::write(&workspace_file, valid).unwrap();
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
|
||||
@@ -15,6 +15,8 @@ tokio.workspace = true
|
||||
tracing.workspace = true
|
||||
parking_lot.workspace = true
|
||||
reqwest.workspace = true
|
||||
# The system proxy reqwest reads, to notice when it changes (see `client::shared`).
|
||||
hyper-util = { version = "0.1", default-features = false, features = ["client-proxy", "client-proxy-system"] }
|
||||
rustls.workspace = true
|
||||
rustls-platform-verifier.workspace = true
|
||||
uuid.workspace = true
|
||||
|
||||
@@ -5,7 +5,7 @@ use ide_core::proxy_settings::{ProxyMode, ProxyRoute, ProxySettings};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use parking_lot::Mutex;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
/// `builder` routed as `proxy` says: direct, the environment's proxy (reqwest's
|
||||
/// default), or the manual proxy except for the "No proxy for" hosts.
|
||||
@@ -62,18 +62,61 @@ pub fn build_with_redirect(proxy: &ProxySettings, redirect: reqwest::redirect::P
|
||||
with_proxy(builder, proxy).build().map_err(|e| fail(e.to_string()))
|
||||
}
|
||||
|
||||
/// A client built for these proxy settings and, in Auto mode, this system proxy.
|
||||
struct Cached {
|
||||
settings: Arc<ProxySettings>,
|
||||
system: Option<String>,
|
||||
client: reqwest::Client,
|
||||
}
|
||||
|
||||
/// The client for the current proxy settings, rebuilt when they change.
|
||||
pub fn shared() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<(Arc<ProxySettings>, reqwest::Client)>> = Mutex::new(None);
|
||||
let proxy = ide_core::proxy_settings::proxy();
|
||||
let mut cached = CLIENT.lock();
|
||||
if let Some((settings, client)) = cached.as_ref()
|
||||
&& **settings == *proxy
|
||||
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, build, system_proxy)
|
||||
}
|
||||
|
||||
/// The client the HTTP Client executes requests with: redirects off, `exec`
|
||||
/// follows them by hand — that is what lets a `POST` stay a `POST` on a
|
||||
/// 301/302 and puts the redirect chain into the response.
|
||||
pub fn shared_without_redirects() -> IdeResult<reqwest::Client> {
|
||||
static CLIENT: Mutex<Option<Cached>> = Mutex::new(None);
|
||||
cached_client(&CLIENT, |proxy| build_with_redirect(proxy, reqwest::redirect::Policy::none()), system_proxy)
|
||||
}
|
||||
|
||||
/// The system proxy (the environment's, then macOS / Windows settings) as reqwest reads
|
||||
/// it when a client is built, re-read at most every few seconds. A client in Auto mode
|
||||
/// keeps the proxy it was built with, so a proxy app that switches the system proxy on
|
||||
/// after launch would otherwise leave downloads going direct until a restart.
|
||||
fn system_proxy() -> String {
|
||||
static LAST: Mutex<Option<(Instant, String)>> = Mutex::new(None);
|
||||
let mut last = LAST.lock();
|
||||
if let Some((at, seen)) = last.as_ref()
|
||||
&& at.elapsed() < Duration::from_secs(3)
|
||||
{
|
||||
return Ok(client.clone());
|
||||
return seen.clone();
|
||||
}
|
||||
// Credentials are left out of the matcher's `Debug`.
|
||||
let seen = format!("{:?}", hyper_util::client::proxy::matcher::Matcher::from_system());
|
||||
*last = Some((Instant::now(), seen.clone()));
|
||||
seen
|
||||
}
|
||||
|
||||
fn cached_client(
|
||||
slot: &Mutex<Option<Cached>>,
|
||||
build: impl Fn(&ProxySettings) -> IdeResult<reqwest::Client>,
|
||||
system: fn() -> String,
|
||||
) -> IdeResult<reqwest::Client> {
|
||||
let proxy = ide_core::proxy_settings::proxy();
|
||||
let system = (proxy.mode == ProxyMode::Auto).then(system);
|
||||
let mut cached = slot.lock();
|
||||
if let Some(c) = cached.as_ref()
|
||||
&& *c.settings == *proxy
|
||||
&& c.system == system
|
||||
{
|
||||
return Ok(c.client.clone());
|
||||
}
|
||||
let client = build(&proxy)?;
|
||||
*cached = Some((proxy, client.clone()));
|
||||
*cached = Some(Cached { settings: proxy, system, client: client.clone() });
|
||||
Ok(client)
|
||||
}
|
||||
|
||||
@@ -127,6 +170,36 @@ pub fn describe(e: &reqwest::Error) -> String {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn auto_mode_rebuilds_the_shared_client_when_the_system_proxy_changes() {
|
||||
static SYSTEM: Mutex<String> = Mutex::new(String::new());
|
||||
static BUILDS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
fn system() -> String {
|
||||
SYSTEM.lock().clone()
|
||||
}
|
||||
let slot = Mutex::new(None);
|
||||
let get = || {
|
||||
cached_client(
|
||||
&slot,
|
||||
|proxy| {
|
||||
BUILDS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
build(proxy)
|
||||
},
|
||||
system,
|
||||
)
|
||||
.unwrap()
|
||||
};
|
||||
assert_eq!(ide_core::proxy_settings::proxy().mode, ProxyMode::Auto);
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 1);
|
||||
// A proxy app switches the system proxy on after launch.
|
||||
*SYSTEM.lock() = "Matcher { https: 127.0.0.1:7890 }".into();
|
||||
get();
|
||||
get();
|
||||
assert_eq!(BUILDS.load(std::sync::atomic::Ordering::SeqCst), 2);
|
||||
}
|
||||
use ide_core::proxy_settings::ProxyKind;
|
||||
use std::io::{BufRead, BufReader, Write};
|
||||
use std::net::TcpListener;
|
||||
|
||||
@@ -13,6 +13,19 @@ use std::time::Instant;
|
||||
/// Bodies above this are cut (the full size is still reported).
|
||||
pub const MAX_BODY: usize = 16 * 1024 * 1024;
|
||||
|
||||
/// Redirects followed per request; beyond this the redirect response itself is
|
||||
/// returned (IntelliJ's HTTP Client follows the same number).
|
||||
pub const MAX_REDIRECTS: usize = 50;
|
||||
|
||||
/// Responses whose `Location` is followed: 301, 302, 303, 307 and 308, the set
|
||||
/// IntelliJ's HTTP Client redirects on.
|
||||
const REDIRECT_STATUSES: [u16; 5] = [301, 302, 303, 307, 308];
|
||||
|
||||
/// Request headers not re-sent to a redirect on another host. IntelliJ's HTTP
|
||||
/// Client strips the same set and restores it when the redirect stays on the
|
||||
/// original host.
|
||||
const SENSITIVE_HEADERS: [&str; 5] = ["authorization", "cookie", "cookie2", "www-authenticate", "proxy-authorization"];
|
||||
|
||||
/// A request ready to send: variables substituted, includes read.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -24,6 +37,15 @@ pub struct PreparedRequest {
|
||||
pub body: Option<String>,
|
||||
}
|
||||
|
||||
/// One followed redirect: the response and the `Location` it pointed to.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RedirectHop {
|
||||
pub status: u16,
|
||||
pub status_text: String,
|
||||
pub location: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct HttpResponse {
|
||||
@@ -32,6 +54,9 @@ pub struct HttpResponse {
|
||||
pub version: String,
|
||||
pub headers: Vec<(String, String)>,
|
||||
pub content_type: Option<String>,
|
||||
/// Followed redirects, first hop first; empty when not redirected.
|
||||
#[serde(default)]
|
||||
pub redirects: Vec<RedirectHop>,
|
||||
/// Body as text (lossy UTF-8); `None` for binary bodies.
|
||||
pub body: Option<String>,
|
||||
/// Size in bytes as received (after decompression).
|
||||
@@ -128,25 +153,84 @@ fn looks_textual(content_type: Option<&str>, bytes: &[u8]) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Sends `req`; cancelled when `cancel` fires.
|
||||
/// The request for one hop: `req`'s headers and body against `url`, the
|
||||
/// sensitive headers dropped when the redirect crosses to another host.
|
||||
fn request_to(
|
||||
client: &reqwest::Client,
|
||||
method: &reqwest::Method,
|
||||
req: &PreparedRequest,
|
||||
body: Option<&str>,
|
||||
original: &reqwest::Url,
|
||||
url: &reqwest::Url,
|
||||
) -> IdeResult<reqwest::Request> {
|
||||
let same_host = url.host_str() == original.host_str();
|
||||
let mut builder = client.request(method.clone(), url.clone());
|
||||
for (k, v) in &req.headers {
|
||||
if same_host || !SENSITIVE_HEADERS.iter().any(|s| k.eq_ignore_ascii_case(s)) {
|
||||
builder = builder.header(k, v);
|
||||
}
|
||||
}
|
||||
if let Some(body) = body {
|
||||
builder = builder.body(body.to_owned());
|
||||
}
|
||||
builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))
|
||||
}
|
||||
|
||||
/// Sends `request`; cancelled when `cancel` fires.
|
||||
async fn send(
|
||||
client: &reqwest::Client,
|
||||
request: reqwest::Request,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<reqwest::Response> {
|
||||
let send = client.execute(request);
|
||||
tokio::select! {
|
||||
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e))),
|
||||
() = cancel.cancelled() => Err(IdeError::cancelled()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Sends `req`, following redirects the way IntelliJ's HTTP Client does:
|
||||
/// 301, 302, 303, 307 and 308 up to [`MAX_REDIRECTS`] times, `303` continuing
|
||||
/// as `GET` without the body, the other statuses keeping the method and body —
|
||||
/// so a `POST` redirected to `https` on the same host is re-sent as a `POST`.
|
||||
/// Sensitive headers (Authorization, cookies, proxy credentials) are not
|
||||
/// re-sent across hosts. The followed hops are reported in the response.
|
||||
/// Cancelled when `cancel` fires.
|
||||
pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeResult<HttpResponse> {
|
||||
let client = crate::client::shared()?;
|
||||
let client = crate::client::shared_without_redirects()?;
|
||||
let method = reqwest::Method::from_bytes(req.method.as_bytes())
|
||||
.map_err(|_| IdeError::invalid(format!("invalid method {}", req.method)))?;
|
||||
let mut builder = client.request(method, &req.url);
|
||||
for (k, v) in &req.headers {
|
||||
builder = builder.header(k, v);
|
||||
}
|
||||
if let Some(body) = &req.body {
|
||||
builder = builder.body(body.clone());
|
||||
}
|
||||
let request = builder.build().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
|
||||
let original = req.url.parse::<reqwest::Url>().map_err(|e| IdeError::invalid(format!("invalid request: {e}")))?;
|
||||
let mut url = original.clone();
|
||||
let mut method = method;
|
||||
let mut body = req.body.clone();
|
||||
let mut redirects = Vec::new();
|
||||
let started = Instant::now();
|
||||
let send = client.execute(request);
|
||||
let mut response = tokio::select! {
|
||||
r = send => r.map_err(|e| IdeError::new(ide_core::error::ErrorKind::Io, describe(&e)))?,
|
||||
() = cancel.cancelled() => return Err(IdeError::cancelled()),
|
||||
};
|
||||
let mut response;
|
||||
loop {
|
||||
let request = request_to(&client, &method, req, body.as_deref(), &original, &url)?;
|
||||
response = send(&client, request, cancel).await?;
|
||||
let status = response.status();
|
||||
if redirects.len() >= MAX_REDIRECTS || !REDIRECT_STATUSES.contains(&status.as_u16()) {
|
||||
break;
|
||||
}
|
||||
let next = response
|
||||
.headers()
|
||||
.get(reqwest::header::LOCATION)
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.and_then(|location| url.join(location).ok());
|
||||
let Some(next) = next else { break };
|
||||
redirects.push(RedirectHop {
|
||||
status: status.as_u16(),
|
||||
status_text: status.canonical_reason().unwrap_or("").to_owned(),
|
||||
location: next.to_string(),
|
||||
});
|
||||
if status == reqwest::StatusCode::SEE_OTHER {
|
||||
method = reqwest::Method::GET;
|
||||
body = None;
|
||||
}
|
||||
url = next;
|
||||
}
|
||||
let ttfb = started.elapsed();
|
||||
let status = response.status();
|
||||
let version = format!("{:?}", response.version());
|
||||
@@ -179,6 +263,7 @@ pub async fn execute(req: &PreparedRequest, cancel: &CancellationToken) -> IdeRe
|
||||
version,
|
||||
headers,
|
||||
content_type,
|
||||
redirects,
|
||||
body,
|
||||
size: size as f64,
|
||||
truncated: size > bytes.len(),
|
||||
@@ -249,6 +334,47 @@ mod tests {
|
||||
assert_eq!(url("GET https://api.test/cb?u=http://x\n"), "https://api.test/cb?u=http://x");
|
||||
}
|
||||
|
||||
/// A loopback server answering each accepted connection with the next of
|
||||
/// `responses`, returning every request as its head and body.
|
||||
async fn scripted(responses: Vec<String>) -> (u16, tokio::task::JoinHandle<Vec<(String, String)>>) {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let handle = tokio::spawn(async move {
|
||||
let mut seen = Vec::new();
|
||||
for response in responses {
|
||||
let (mut socket, _) = listener.accept().await.unwrap();
|
||||
let mut request = Vec::new();
|
||||
let (head, body) = loop {
|
||||
let mut buffer = [0u8; 4096];
|
||||
let read = socket.read(&mut buffer).await.unwrap();
|
||||
assert!(read > 0, "request ended before its body");
|
||||
request.extend_from_slice(&buffer[..read]);
|
||||
let Some(end) = request.windows(4).position(|w| w == b"\r\n\r\n") else { continue };
|
||||
let head = String::from_utf8_lossy(&request[..end]).into_owned();
|
||||
let length: usize = head
|
||||
.lines()
|
||||
.find_map(|line| {
|
||||
let (name, value) = line.split_once(':')?;
|
||||
name.eq_ignore_ascii_case("content-length").then(|| value.trim().parse().unwrap())
|
||||
})
|
||||
.unwrap_or(0);
|
||||
if request.len() >= end + 4 + length {
|
||||
break (head, String::from_utf8_lossy(&request[end + 4..end + 4 + length]).into_owned());
|
||||
}
|
||||
};
|
||||
seen.push((head, body));
|
||||
socket.write_all(response.as_bytes()).await.unwrap();
|
||||
}
|
||||
seen
|
||||
});
|
||||
(port, handle)
|
||||
}
|
||||
|
||||
fn response(status_line: &str, headers: &str, body: &str) -> String {
|
||||
format!("HTTP/1.1 {status_line}\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn sends_exact_environment_numbers_to_a_local_server() {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
@@ -341,6 +467,7 @@ mod tests {
|
||||
assert_eq!(r.status_text, "Created");
|
||||
assert_eq!(r.body.as_deref(), Some("{\"ok\":true}"));
|
||||
assert!(r.headers.iter().any(|(k, v)| k == "x-a" && v == "b"));
|
||||
assert!(r.redirects.is_empty());
|
||||
assert!(r.total_ms >= r.ttfb_ms);
|
||||
}
|
||||
|
||||
@@ -369,4 +496,150 @@ mod tests {
|
||||
let err = execute(&req, &cancel).await.unwrap_err();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn post_keeps_method_and_body_on_301_302_307_308() {
|
||||
for status_line in ["301 Moved Permanently", "302 Found", "307 Temporary Redirect", "308 Permanent Redirect"] {
|
||||
let status: u16 = status_line[..3].parse().unwrap();
|
||||
let (port, server) =
|
||||
scripted(vec![response(status_line, "Location: /landing\r\n", ""), response("200 OK", "", "ok")]).await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "POST".into(),
|
||||
url: format!("http://127.0.0.1:{port}/submit"),
|
||||
headers: vec![("Content-Type".into(), "application/json".into())],
|
||||
body: Some("{\"a\":1}".into()),
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
let (head, body) = &seen[1];
|
||||
assert_eq!(head.lines().next().unwrap(), "POST /landing HTTP/1.1", "{status_line}");
|
||||
assert!(head.to_ascii_lowercase().contains("content-type: application/json"), "{head}");
|
||||
assert_eq!(body, "{\"a\":1}", "{status_line}");
|
||||
assert_eq!(r.status, 200, "{status_line}");
|
||||
assert_eq!(r.body.as_deref(), Some("ok"), "{status_line}");
|
||||
assert_eq!(
|
||||
r.redirects,
|
||||
vec![RedirectHop {
|
||||
status,
|
||||
status_text: status_line[4..].to_owned(),
|
||||
location: format!("http://127.0.0.1:{port}/landing"),
|
||||
}],
|
||||
"{status_line}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn see_other_303_resends_as_get_without_the_body() {
|
||||
let (port, server) =
|
||||
scripted(vec![response("303 See Other", "Location: /after\r\n", ""), response("200 OK", "", "done")]).await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "POST".into(),
|
||||
url: format!("http://127.0.0.1:{port}/submit"),
|
||||
headers: vec![],
|
||||
body: Some("{\"a\":1}".into()),
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert_eq!(seen[1].0.lines().next().unwrap(), "GET /after HTTP/1.1");
|
||||
assert_eq!(seen[1].1, "");
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.body.as_deref(), Some("done"));
|
||||
assert_eq!(r.redirects[0].status, 303);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn same_host_redirect_keeps_authorization() {
|
||||
let (port, server) = scripted(vec![
|
||||
response("301 Moved Permanently", "Location: /landing\r\n", ""),
|
||||
response("200 OK", "", "ok"),
|
||||
])
|
||||
.await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "GET".into(),
|
||||
url: format!("http://127.0.0.1:{port}/start"),
|
||||
headers: vec![("Authorization".into(), "Bearer secret".into())],
|
||||
body: None,
|
||||
};
|
||||
execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert!(seen[1].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen[1].0);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cross_host_redirect_keeps_the_method_but_drops_authorization() {
|
||||
let (port_b, server_b) = scripted(vec![response("200 OK", "", "moved")]).await;
|
||||
let (port_a, server_a) = scripted(vec![response(
|
||||
"301 Moved Permanently",
|
||||
&format!("Location: http://127.0.0.1:{port_b}/x\r\n"),
|
||||
"",
|
||||
)])
|
||||
.await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "POST".into(),
|
||||
url: format!("http://localhost:{port_a}/start"),
|
||||
headers: vec![("Authorization".into(), "Bearer secret".into())],
|
||||
body: Some("{\"a\":1}".into()),
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen_a = server_a.await.unwrap();
|
||||
let seen_b = server_b.await.unwrap();
|
||||
assert!(seen_a[0].0.to_ascii_lowercase().contains("authorization: bearer secret"), "{}", seen_a[0].0);
|
||||
assert_eq!(seen_b[0].0.lines().next().unwrap(), "POST /x HTTP/1.1");
|
||||
assert!(!seen_b[0].0.to_ascii_lowercase().contains("authorization"), "{}", seen_b[0].0);
|
||||
assert_eq!(seen_b[0].1, "{\"a\":1}");
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.body.as_deref(), Some("moved"));
|
||||
assert_eq!(r.redirects.len(), 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn redirects_beyond_the_limit_return_the_last_redirect_response() {
|
||||
let responses = vec![response("301 Moved Permanently", "Location: /loop\r\n", ""); MAX_REDIRECTS + 1];
|
||||
let (port, server) = scripted(responses).await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "GET".into(),
|
||||
url: format!("http://127.0.0.1:{port}/start"),
|
||||
headers: vec![],
|
||||
body: None,
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert_eq!(r.status, 301);
|
||||
assert_eq!(r.status_text, "Moved Permanently");
|
||||
assert_eq!(r.redirects.len(), MAX_REDIRECTS);
|
||||
assert_eq!(seen.len(), MAX_REDIRECTS + 1);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn redirect_chain_is_recorded_across_hops() {
|
||||
let (port, server) = scripted(vec![
|
||||
response("302 Found", "Location: /b\r\n", ""),
|
||||
response("302 Found", "Location: /c\r\n", ""),
|
||||
response("200 OK", "", "end"),
|
||||
])
|
||||
.await;
|
||||
let req = PreparedRequest {
|
||||
name: None,
|
||||
method: "GET".into(),
|
||||
url: format!("http://127.0.0.1:{port}/a"),
|
||||
headers: vec![],
|
||||
body: None,
|
||||
};
|
||||
let r = execute(&req, &CancellationToken::new()).await.unwrap();
|
||||
let seen = server.await.unwrap();
|
||||
assert_eq!(r.status, 200);
|
||||
assert_eq!(r.body.as_deref(), Some("end"));
|
||||
assert_eq!(r.redirects.len(), 2);
|
||||
assert_eq!(r.redirects[0].status, 302);
|
||||
assert_eq!(r.redirects[0].location, format!("http://127.0.0.1:{port}/b"));
|
||||
assert_eq!(r.redirects[1].status, 302);
|
||||
assert_eq!(r.redirects[1].location, format!("http://127.0.0.1:{port}/c"));
|
||||
assert_eq!(seen[2].0.lines().next().unwrap(), "GET /c HTTP/1.1");
|
||||
}
|
||||
}
|
||||
@@ -265,7 +265,7 @@ impl ProjectIndex {
|
||||
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
let recent = self.shared.recent.lock().clone();
|
||||
let d = self.shared.data.read();
|
||||
matching::find_files(&d, &matching::Recents::new(&recent), query, limit)
|
||||
matching::find_files(&d, &matching::Recents::new(&recent), query, Some(&self.root), limit)
|
||||
}
|
||||
|
||||
/// All indexed files with this exact basename, for resolving printed source locations.
|
||||
@@ -301,7 +301,7 @@ impl ProjectIndex {
|
||||
|
||||
/// Fuzzy search for folders that hold indexed files; `rel_path` ends in `/`.
|
||||
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_dirs(&self.shared.data.read(), query, limit)
|
||||
matching::find_dirs(&self.shared.data.read(), query, Some(&self.root), limit)
|
||||
}
|
||||
|
||||
/// Fuzzy symbol search; CamelHump aware (`OCo` → `OrderController`).
|
||||
@@ -574,11 +574,11 @@ pub mod bench_support {
|
||||
}
|
||||
|
||||
pub fn find_files(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, limit)
|
||||
matching::find_files(&self.data, &matching::Recents::new(&self.recent), query, None, limit)
|
||||
}
|
||||
|
||||
pub fn find_dirs(&self, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
matching::find_dirs(&self.data, query, limit)
|
||||
matching::find_dirs(&self.data, query, None, limit)
|
||||
}
|
||||
|
||||
pub fn find_symbols(&self, query: &str, filter: SymbolFilter, limit: usize) -> Vec<SymbolMatch> {
|
||||
|
||||
@@ -205,29 +205,67 @@ impl<'a> Recents<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; strips leading `./` and `/`.
|
||||
fn normalize_file_query(q: &str) -> String {
|
||||
/// `Foo.kt:12:3` -> `Foo.kt`; `\` -> `/`; a pasted absolute path under `root` -> its project-relative
|
||||
/// form; strips leading `./` and `/`.
|
||||
fn normalize_file_query(q: &str, root: Option<&Path>) -> String {
|
||||
let mut q = q.trim().replace('\\', "/");
|
||||
// `\\?\C:\a` (verbatim) and `\\.\C:\a` name `C:/a`.
|
||||
if let Some(rest) = verbatim_target(&q) {
|
||||
q = rest.to_owned();
|
||||
}
|
||||
while let Some((head, tail)) = q.rsplit_once(':')
|
||||
&& !tail.is_empty()
|
||||
&& tail.bytes().all(|b| b.is_ascii_digit())
|
||||
{
|
||||
q = head.to_owned();
|
||||
}
|
||||
if let Some(root) = root
|
||||
&& let Some(rel) = strip_root(&q, root)
|
||||
{
|
||||
q = rel;
|
||||
}
|
||||
let q = q.trim_start_matches("./").trim_start_matches('/');
|
||||
q.chars().filter(|c| !c.is_whitespace()).collect()
|
||||
}
|
||||
|
||||
/// Path a `\\?\` / `\\.\` verbatim prefix points at, for a `/`-separated path.
|
||||
fn verbatim_target(q: &str) -> Option<&str> {
|
||||
q.strip_prefix("//?/").or_else(|| q.strip_prefix("//./"))
|
||||
}
|
||||
|
||||
/// `q` (already `/`-separated) below `root`, without the separating slash. A drive-letter root
|
||||
/// compares like Windows, where case does not matter.
|
||||
fn strip_root(q: &str, root: &Path) -> Option<String> {
|
||||
let root = root.to_string_lossy().replace('\\', "/");
|
||||
let root = verbatim_target(&root).unwrap_or(&root);
|
||||
let root = root.trim_end_matches('/');
|
||||
let windows = root.as_bytes().get(1) == Some(&b':');
|
||||
let head = q.get(..root.len())?;
|
||||
if head != root && !(windows && head.eq_ignore_ascii_case(root)) {
|
||||
return None;
|
||||
}
|
||||
match q.get(root.len()..)? {
|
||||
"" => Some(String::new()),
|
||||
tail => tail.strip_prefix('/').map(str::to_owned),
|
||||
}
|
||||
}
|
||||
|
||||
enum FileQuery {
|
||||
Name(Needle),
|
||||
Path { dir: Needle, name: Needle },
|
||||
}
|
||||
|
||||
pub(crate) fn find_files(data: &IndexData, recents: &Recents, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
pub(crate) fn find_files(
|
||||
data: &IndexData,
|
||||
recents: &Recents,
|
||||
query: &str,
|
||||
root: Option<&Path>,
|
||||
limit: usize,
|
||||
) -> Vec<FileMatch> {
|
||||
if limit == 0 {
|
||||
return Vec::new();
|
||||
}
|
||||
let q = normalize_file_query(query);
|
||||
let q = normalize_file_query(query, root);
|
||||
if q.is_empty() {
|
||||
return recents
|
||||
.paths
|
||||
@@ -306,8 +344,8 @@ pub(crate) fn find_files(data: &IndexData, recents: &Recents, query: &str, limit
|
||||
|
||||
/// Fuzzy folder search over the folders holding indexed files: folder-name matches beat
|
||||
/// path matches; `/` in the query matches the whole path. `rel_path` ends in `/`.
|
||||
pub(crate) fn find_dirs(data: &IndexData, query: &str, limit: usize) -> Vec<FileMatch> {
|
||||
let q = normalize_file_query(query);
|
||||
pub(crate) fn find_dirs(data: &IndexData, query: &str, root: Option<&Path>, limit: usize) -> Vec<FileMatch> {
|
||||
let q = normalize_file_query(query, root);
|
||||
if limit == 0 || q.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
@@ -673,8 +711,18 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn normalizes_queries() {
|
||||
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 "), "src/main.rs");
|
||||
assert_eq!(normalize_file_query("/a b"), "ab");
|
||||
let root = Path::new("E:/work/sample");
|
||||
assert_eq!(normalize_file_query(" ./src\\main.rs:12:4 ", None), "src/main.rs");
|
||||
assert_eq!(normalize_file_query("/a b", None), "ab");
|
||||
// A pasted absolute path names an indexed file (#4079 follow-up).
|
||||
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go", Some(root)), "pkg/Config.go");
|
||||
assert_eq!(normalize_file_query(r"e:/WORK/sample\pkg/Config.go", Some(root)), "pkg/Config.go");
|
||||
assert_eq!(normalize_file_query(r"\\?\E:\work\sample\src\App.kt", Some(root)), "src/App.kt");
|
||||
assert_eq!(normalize_file_query(r"E:\work\sample\pkg\Config.go:12:4", Some(root)), "pkg/Config.go");
|
||||
// Outside the project, and a POSIX root, keep the path as given.
|
||||
assert_eq!(normalize_file_query(r"E:\elsewhere\x.go", Some(root)), "E:/elsewhere/x.go");
|
||||
assert_eq!(normalize_file_query("/home/me/Src/a.rs", Some(Path::new("/home/me/src"))), "home/me/Src/a.rs");
|
||||
assert_eq!(normalize_file_query("/home/me/src/a.rs", Some(Path::new("/home/me/src"))), "a.rs");
|
||||
assert_eq!(split_symbol_query("Order.save"), (Some("Order"), "save"));
|
||||
assert_eq!(split_symbol_query("a::b::C::new"), (Some("C"), "new"));
|
||||
assert_eq!(split_symbol_query("save"), (None, "save"));
|
||||
|
||||
@@ -13,6 +13,9 @@ const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
|
||||
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
|
||||
/// Bump when [`FileRecord`] or its encoding changes. 4: a symbol's base names.
|
||||
const SCHEMA: &str = "openidea-index-4";
|
||||
/// redb's page cache, which otherwise grows to 1 GiB. Queries run on the in-memory snapshot;
|
||||
/// the database is read once at startup and written incrementally.
|
||||
const DB_CACHE_BYTES: usize = 64 * 1024 * 1024;
|
||||
|
||||
/// The real Git directory for a checkout/worktree (`root/.git` may be a file
|
||||
/// containing `gitdir: ...`).
|
||||
@@ -389,7 +392,7 @@ impl Store {
|
||||
|
||||
fn open_db(&self) -> Result<Database> {
|
||||
let file = self.snapshot.with_file_name("index.redb");
|
||||
let db = match Database::create(&file) {
|
||||
let db = match Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file) {
|
||||
Ok(db) => db,
|
||||
Err(redb::DatabaseError::DatabaseAlreadyOpen) => {
|
||||
return Err(format!("{} is in use", file.display()));
|
||||
@@ -398,7 +401,7 @@ impl Store {
|
||||
tracing::warn!("index cache {} unreadable ({e}); rebuilding", file.display());
|
||||
let _ = std::fs::remove_file(&file);
|
||||
let _ = std::fs::remove_file(&self.snapshot);
|
||||
Database::create(&file).map_err(err)?
|
||||
Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file).map_err(err)?
|
||||
}
|
||||
};
|
||||
let valid = {
|
||||
|
||||
@@ -190,6 +190,19 @@ fn file_ranking_is_idea_like() {
|
||||
assert_eq!(shown.to_lowercase(), "uibtn");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_pasted_absolute_path_finds_the_indexed_file() {
|
||||
let fx = sample();
|
||||
let idx = fx.open();
|
||||
let abs = fx.root.join("src/ui/Button.tsx");
|
||||
let abs = abs.to_string_lossy().into_owned();
|
||||
assert_eq!(files(&idx, &abs)[0], "src/ui/Button.tsx");
|
||||
// A trailing `:line:col`, and a path outside the project that names no file.
|
||||
assert_eq!(files(&idx, &format!("{abs}:12:4"))[0], "src/ui/Button.tsx");
|
||||
let outside = fx.root.parent().unwrap().join("elsewhere/Button.tsx");
|
||||
assert!(files(&idx, &outside.to_string_lossy()).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn find_dirs_ranks_folder_names() {
|
||||
let f = sample();
|
||||
|
||||
@@ -472,6 +472,8 @@ impl Shared {
|
||||
|
||||
fn full_scan(&self, found: Option<Vec<Found>>, guard: SystemTime) {
|
||||
self.scan(None, found, guard);
|
||||
// Parsing every file churns through far more memory than the index keeps.
|
||||
ide_core::memory::release_free_pages();
|
||||
}
|
||||
|
||||
fn scan(&self, dirs: Option<&[PathBuf]>, prewalked: Option<Vec<Found>>, guard: SystemTime) -> Option<ScanCounts> {
|
||||
|
||||
@@ -25,7 +25,7 @@ impl LspManager {
|
||||
/// Whether jdtls serves the Java files of `path`. Without it, launches build with the
|
||||
/// build tool and take the classpath from [`Self::java_server_classpath`] or the build model.
|
||||
pub fn java_served_by_jdtls(&self, path: &Path) -> bool {
|
||||
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS)
|
||||
self.servers_for(&LanguageId::new("java"), path).iter().any(|s| s.name == JDTLS && !s.gave_up())
|
||||
}
|
||||
|
||||
/// The java-analyzer executable among the Java servers of `path`, whatever the server is
|
||||
@@ -107,6 +107,27 @@ fn is_java_analyzer(binary: &Path) -> bool {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::server::Conn;
|
||||
use ide_core::event::ServerStatus;
|
||||
use ide_language::LanguageRegistry;
|
||||
use std::sync::Arc;
|
||||
|
||||
#[test]
|
||||
fn missing_jdtls_leaves_java_analyzer_to_serve_the_module() {
|
||||
let project = tempfile::tempdir().unwrap();
|
||||
let root = project.path();
|
||||
let manager =
|
||||
LspManager::new(root.to_path_buf(), Arc::new(LanguageRegistry::load(None).unwrap()), Arc::new(|_| {}));
|
||||
assert!(manager.java_served_by_jdtls(root));
|
||||
assert!(manager.java_analyzer_binary(root).is_none());
|
||||
|
||||
let jdtls = manager.servers_for(&LanguageId::new("java"), root).into_iter().find(|s| s.name == JDTLS).unwrap();
|
||||
let generation = jdtls.begin_start().unwrap();
|
||||
assert!(jdtls.fail_start(generation, Conn::Missing, manager.sink(), ServerStatus::Missing, None));
|
||||
|
||||
assert!(!manager.java_served_by_jdtls(root));
|
||||
assert_eq!(manager.java_analyzer_binary(root).as_deref(), Some(Path::new("java-analyzer")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recognises_java_analyzer_by_its_executable() {
|
||||
|
||||
@@ -1049,12 +1049,14 @@ impl LspManager {
|
||||
if let Err(e) = peer.notify("initialized", json!({})) {
|
||||
tracing::warn!("{}: {e}", server.name);
|
||||
}
|
||||
// Servers that don't ask with `workspace/configuration` only learn settings this way.
|
||||
let cfg = server.effective_config();
|
||||
if cfg.settings.is_some()
|
||||
&& let Err(e) =
|
||||
peer.notify("workspace/didChangeConfiguration", json!({ "settings": handler::all_settings(&cfg) }))
|
||||
{
|
||||
// Sent even without settings: servers that don't ask with `workspace/configuration`
|
||||
// only learn settings this way, and Pyright, given workspace folders, waits for it
|
||||
// before asking and loading the workspace.
|
||||
let mut settings = handler::all_settings(&server.effective_config());
|
||||
if settings.is_null() {
|
||||
settings = json!({});
|
||||
}
|
||||
if let Err(e) = peer.notify("workspace/didChangeConfiguration", json!({ "settings": settings })) {
|
||||
tracing::debug!("{}: didChangeConfiguration: {e}", server.name);
|
||||
}
|
||||
|
||||
|
||||
@@ -1324,6 +1324,36 @@ async fn initialize_and_incremental_sync() {
|
||||
assert_eq!(infos[0].status, ServerStatus::Ready);
|
||||
}
|
||||
|
||||
/// Pyright, told the client has workspace folders, asks for its configuration and loads the
|
||||
/// workspace only after a `workspace/didChangeConfiguration`: every server gets one at startup.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn every_server_hears_its_configuration_once_initialized() {
|
||||
let cases = [
|
||||
(None, None, json!({})),
|
||||
(Some(json!({ "flag": true })), None, json!({ "flag": true })),
|
||||
(
|
||||
None,
|
||||
Some(json!({ "python": { "pythonPath": "/venv/bin/python" } })),
|
||||
json!({ "python": { "pythonPath": "/venv/bin/python" } }),
|
||||
),
|
||||
(Some(json!({ "flag": true })), Some(json!({ "other": 2 })), json!({ "flag": true, "other": 2 })),
|
||||
];
|
||||
for (init, settings, expected) in cases {
|
||||
let h = harness_configured("mock", "mk", &[("pyright", incremental_caps())], |cfg| {
|
||||
cfg.initialization_options = init.clone().map(|v| toml::Value::try_from(v).unwrap());
|
||||
cfg.settings = settings.clone();
|
||||
});
|
||||
h.open("a.mk", "x");
|
||||
h.wait_status("pyright", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("pyright");
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
assert_eq!(s.notified("workspace/didChangeConfiguration"), vec![json!({ "settings": expected })]);
|
||||
let order: Vec<String> = s.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
let at = |m: &str| order.iter().position(|n| n == m).unwrap();
|
||||
assert!(at("initialized") < at("workspace/didChangeConfiguration"));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn full_sync_and_desync_recovery() {
|
||||
let h = harness(&[("full", json!({ "textDocumentSync": 1 })), ("inc", json!({ "textDocumentSync": 2 }))]);
|
||||
@@ -2650,7 +2680,16 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
|
||||
.await;
|
||||
assert_eq!(s.notified("textDocument/didChange").len(), 2, "one re-sync per answer");
|
||||
let methods: Vec<String> = extra.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
|
||||
assert_eq!(methods, ["initialized", "textDocument/didOpen", "textDocument/didChange", "textDocument/didSave"]);
|
||||
assert_eq!(
|
||||
methods,
|
||||
[
|
||||
"initialized",
|
||||
"workspace/didChangeConfiguration",
|
||||
"textDocument/didOpen",
|
||||
"textDocument/didChange",
|
||||
"textDocument/didSave"
|
||||
]
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
@@ -2706,9 +2745,9 @@ async fn settings_changes_reach_servers_without_restarts() {
|
||||
let s = h.launcher.state("mock");
|
||||
*settings.lock() = Some(json!({ "nested": { "other": 2 } }));
|
||||
h.mgr.reconfigure().await;
|
||||
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
|
||||
eventually(|| s.notified("workspace/didChangeConfiguration").len() == 2).await;
|
||||
assert_eq!(
|
||||
s.notified("workspace/didChangeConfiguration")[0],
|
||||
s.notified("workspace/didChangeConfiguration")[1],
|
||||
json!({ "settings": { "flag": true, "nested": { "deep": 1, "other": 2 } } })
|
||||
);
|
||||
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
|
||||
|
||||
@@ -462,35 +462,54 @@ fn main() {
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires ty on PATH"]
|
||||
async fn ty_python_end_to_end() {
|
||||
python_server_end_to_end("ty").await;
|
||||
}
|
||||
|
||||
/// Pyright loads the workspace only after `workspace/didChangeConfiguration`.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires pyright-langserver on PATH"]
|
||||
async fn pyright_python_end_to_end() {
|
||||
python_server_end_to_end("pyright").await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires basedpyright on PATH"]
|
||||
async fn basedpyright_python_end_to_end() {
|
||||
python_server_end_to_end("basedpyright").await;
|
||||
}
|
||||
|
||||
/// Definition and diagnostics from `name` alone, in a project without configuration.
|
||||
async fn python_server_end_to_end(name: &str) {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().canonicalize().unwrap();
|
||||
let path = root.join("example.py");
|
||||
let source = "def greet(name: str) -> str:\n return name\n\nresult = greet('Ada')\nbad: int = 'wrong'\n";
|
||||
std::fs::write(&path, source).unwrap();
|
||||
let mut python = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("python")).unwrap();
|
||||
python.language_servers.retain(|server| server.name == "ty");
|
||||
python.language_servers.retain(|server| server.name == name);
|
||||
assert_eq!(python.language_servers.len(), 1);
|
||||
python.language_servers[0].fallback = false;
|
||||
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![python]));
|
||||
let doc = DocId::next();
|
||||
mgr.did_open(doc, &path, &LanguageId::new("python"), 1, source);
|
||||
retry("ty ready", Duration::from_secs(30), || {
|
||||
let status = last_status(&events, "ty");
|
||||
retry(&format!("{name} ready"), Duration::from_secs(30), || {
|
||||
let status = last_status(&events, name);
|
||||
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
|
||||
panic!("ty failed: {msg:?}");
|
||||
panic!("{name} failed: {msg:?}");
|
||||
}
|
||||
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
|
||||
})
|
||||
.await;
|
||||
let defs = retry("ty definition", Duration::from_secs(30), || {
|
||||
let defs = retry(&format!("{name} definition"), Duration::from_secs(30), || {
|
||||
let mgr = mgr.clone();
|
||||
async move { mgr.goto(doc, Pos::new(3, 10), GotoKind::Definition).await.ok().filter(|d| !d.is_empty()) }
|
||||
})
|
||||
.await;
|
||||
assert_eq!(defs[0].path, path);
|
||||
assert_eq!(defs[0].range.start.line, 0);
|
||||
retry("ty diagnostics", Duration::from_secs(30), || {
|
||||
retry(&format!("{name} diagnostics"), Duration::from_secs(30), || {
|
||||
let found = events.lock().iter().any(
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == "ty" && !items.is_empty()),
|
||||
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == name && !items.is_empty()),
|
||||
);
|
||||
async move { found.then_some(()) }
|
||||
})
|
||||
|
||||
@@ -1 +1 @@
|
||||
9ec6fcb9763867a747206b0efaf8bbeac7934a4ec0d1915623557839cf2dba5e
|
||||
b59392bcc1999048f0ab922ec659bc21d9e825c696fa41d9f0a40c85627a5b2c
|
||||
+1
-1
@@ -1 +1 @@
|
||||
2015380825fc406a6466f90658443f824ef06311894b82acae2ecc1446ff0813
|
||||
034b99891313c03eb2a6b8c3cb2e4784129e1936965be803512f1d869b1768c2
|
||||
@@ -1 +1 @@
|
||||
7388e5ef7a5bff42f41ed613bfb75a8da835f93a63f8fb26358bb50b77b44c00
|
||||
29ec0a96e2a0f6965915c7c25e35036743fc27a49037df588c217e8abfff93e3
|
||||
@@ -1 +1 @@
|
||||
aded25a93667f14a683b0bbb7547b35eed23e4971fdf2761496b09fd898b5034
|
||||
87b367cfdd65c360920eff7be4d6a8d6b939721f6398aa6a01e39a289590699e
|
||||
+1
-1
@@ -1 +1 @@
|
||||
178bba6e74a51c0911502524f253cf7148854c46883c3f7f96d2c968e70522f5
|
||||
7d034ee1a4b99615642d5bf033802f8e4662216d45b209c4c7a24eb8f1338f48
|
||||
+1
-1
@@ -1 +1 @@
|
||||
786e1abf853d615bf0eab7315280b3884e4c2ff6362c23a41a917d6af4c050e9
|
||||
3fdf985273ec14ae623fa84602a9220cfbfb2e0e587ab192fc2bcb8d990ce9e3
|
||||
+1
-1
@@ -1 +1 @@
|
||||
77a825aa6adc3aa39ee390204e1fd35a12425d0a38552f116c74497dac446046
|
||||
8434e9271e27a6778bb3d5922e8925f3fd9f1d35377e5dddf5b5eb5416bd09bb
|
||||
@@ -1 +1 @@
|
||||
352246ecdba1e3d43127c7b808a3b1cdf48cf0b4ae7d85d532ffaae734158e15
|
||||
9fa7468ce385ff33c1f3b99c84711e0d11a84b10e8e4f95b358fcd2ccc96e255
|
||||
@@ -1 +1 @@
|
||||
da9abe9bd086f7808cc1520a592f47c843f26ecc0a5291110915467f57816dc4
|
||||
5220a5bfb6ec0467a72e63e21d690e70b7d46b4f2eaff4116a8a79220a5eca8f
|
||||
@@ -1 +1 @@
|
||||
322b82aa432e072f8ae1d4345d321d227dbcb9376bd113c166b816254e7ddf13
|
||||
a962127d1c6e37e85b81973a272a5d6b383cc2884b41bb2d82e8640ef5f8f943
|
||||
+1
-1
@@ -1 +1 @@
|
||||
e1ff50682e4aa18ca6bb96547cdd7b2815ad700e6ecaa3aede6d9f20205d4cdb
|
||||
92ad3e43e7f343004dcf26a51e282e97ed694cc9bd7325ff75aa5b18f1a2eeb6
|
||||
+1
-1
@@ -1 +1 @@
|
||||
d3757cea9bcc8e33521c50c66b396d8ece2a90d830c2e57e651ebeb018536c62
|
||||
2200ed0d44dbafb70ad864cb9569b0b2c37cf9eec1582b05efa903a9e8ec89ee
|
||||
+1
-1
@@ -1 +1 @@
|
||||
409e7017849fc68bd3241bfa5357366259e1eb634fb71ef69d4b857bec0aa821
|
||||
644612ee4228010f141042ea0eab5431b8386370f863a70b63cd3315f69d963a
|
||||
@@ -1 +1 @@
|
||||
0b217ad8f0c8f802c1d670422d9621d07553985b9852f3efb724b17688cfa3b9
|
||||
2af5d46516bfc1d38ad1f24d6cf3c57e2d6db6b0d3225748f55c4f13110430fb
|
||||
+1
-1
@@ -1 +1 @@
|
||||
8cc7d2ce4e21838f8f1b0f5bd56aea61257fe288f6b7189343ccf849a78de665
|
||||
0ee0773cefd61b8144d0550718e1988a1e60438bee826c3867350e28886a56f7
|
||||
@@ -1 +1 @@
|
||||
19b8af5e283a0a6ae866538096d2fa95e51020a9fd423768224c2ae4cfcefa27
|
||||
941cb9008aaab11464b193c37b91e2476d771ec526247713f291c6642caf5995
|
||||
@@ -1 +1 @@
|
||||
ccaa7d24825c05409dbcfe1491276b229ee6d712f2ba18556413a87d851c475c
|
||||
06d70aae3152c88d1299a9b33f151b0baa4a77c3ca7145215c6f6e0aa40727b2
|
||||
+1
-1
@@ -1 +1 @@
|
||||
b0ae383f86a8059e0bc723ca1cd21dfa76a0faa68975a1b827b44ebe1ffad2f1
|
||||
86eb87758e4f7c0242a18f12a113c31d418da64d7198041120f19401a5707bfb
|
||||
@@ -1 +1 @@
|
||||
38eadb34cc096538f2b529beb07d10860323356c554dd8171ccc7ca25ebfec8e
|
||||
4442bb686fa18e8e8a52fd1cd8683b8767ec7908ffc1454dff476d9cb1711be9
|
||||
+1
-1
@@ -1 +1 @@
|
||||
1c5c9a19b4dc05219b3c144b21cad6e05a98fe5c01da7c67383cc39223b6e4d8
|
||||
dd51f1b8634ff6305ba1a69c8457bd586996200a2b18e4a08d0cfa2fb60abaf6
|
||||
+1
-1
@@ -1 +1 @@
|
||||
d76fe0c659ef337ae7bb9c75ecfa5a9bcdff2eb92d487ca0df2aefa77bd21daf
|
||||
4319f2655ee1e240b33f4b96c23fff59c61aa62d6ccc628715e5ff9fe38c2717
|
||||
@@ -1 +1 @@
|
||||
f671d361a8de5eead5c4ed801bfeacafb7b0aa82abefddbe2436c4d679a56d37
|
||||
50c4fd7e08a4187afae0e00c775a61578b82bbad056807ad063ee47e79e2cef1
|
||||
+1
-1
@@ -1 +1 @@
|
||||
5cbb5a91f8676fbc0178535f58213eca341c52e210264ffe3da9eb2a47ef02af
|
||||
220666302d814e6d8bde346954205c94c82320d5584d46f01672fd7d32400bf3
|
||||
+1
-1
@@ -1 +1 @@
|
||||
79d5d589c64b66fab58f6fc2cd2a10e91ad23e0dc34b356f6d6d51d7fdcca8b0
|
||||
4ee484afaa1a1f71a9e544582d90db3260307fc89b8f514aaaff883df2761ba6
|
||||
@@ -1 +1 @@
|
||||
4eb1b77f62effb313bf67c1dfe34b8e0718bf5afaf84c8252d664b9a9888d040
|
||||
3fba59ce802d88a2a1c026480a2cb8ce4d9539eb7b88f5a18bf6232f7adef147
|
||||
+1
-1
@@ -1 +1 @@
|
||||
a36c3f0d92237f226d47325dc4e33312f9179e0e05673154fc07d61f6e68f86e
|
||||
73433da25d5304d0a3cb83d750d02feb5e270ee7e9f680c4ee9d923afa9aa066
|
||||
+1
-1
@@ -1 +1 @@
|
||||
2b48734dcf4a8cdf0db0ec80628754a836a0efb2f11dac9fd0fcf80572a23dfe
|
||||
12df43f99eac93f4e1a070635780ad653932cf69a14595175d8ba6d4f0a4445c
|
||||
@@ -1 +1 @@
|
||||
fc1cb738668cee77a4d2a7b48d5543a29d568a8d2231921f5257de6a835be307
|
||||
427b63c11188689262101cde971af0a92e54bd6c88a4e3cc8fdfa1a7c8c95fce
|
||||
@@ -1 +1 @@
|
||||
f609a501e4e752055d9c8f0ff20d1397b0085587f1435af2928e47fe8507f6ca
|
||||
07ae58fe39746b779b1e466d7bbbb666ba550f427c7bf8de97d7ede647c00bc0
|
||||
@@ -1 +1 @@
|
||||
dcacc16856c9b9f11245e4b8c686b1ef6532a0f4090cdf531dafb76f0663a00a
|
||||
f9912644c28512e37299834123cd4c94f6ed11f29bd38ddbc1c92df168447494
|
||||
+1
-1
@@ -1 +1 @@
|
||||
ca252d45f83c5e5b9378d6acec40319db2d6acc636d13bf7e79a5339869f7f09
|
||||
ea0eec8c07d6469d3ab63c3bb08c85b01208be1757edffe5eabcb7be79ccf537
|
||||
@@ -1 +1 @@
|
||||
f54f4b5ac28e44b8d288104a6290557743e68d2b50af4583dc51a01aca7e7777
|
||||
1ce55fabaa5ea1ddf770c8a1ad7f7b60a843c82c453d42289088c4b2fec61d84
|
||||
@@ -1 +1 @@
|
||||
cc98a2e2e74b14a84d3272b41211679a15d06abd4dd664bd87da5ece439e0c00
|
||||
3356b4ec918c668c4c249f84afb9bafcd06c073ba86235b6ceea7ef6220cdaf5
|
||||
@@ -349,64 +349,9 @@ impl RemoteService {
|
||||
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
|
||||
) -> IdeResult<TransferReport> {
|
||||
let fs = self.fs(connection).await?;
|
||||
let mut report = TransferReport::default();
|
||||
let mut folders = Vec::new();
|
||||
let mut jobs = Vec::new();
|
||||
for remote in remotes {
|
||||
let Some(top) = download_target(dir, remote, remote) else {
|
||||
report.skipped += 1;
|
||||
continue;
|
||||
};
|
||||
match fs.stat(remote).await {
|
||||
Ok(Some(e)) if e.is_dir => {
|
||||
folders.push(top);
|
||||
let mut entries = Vec::new();
|
||||
if let Err(e) = remote_tree(&fs, remote, cancel, &mut entries).await {
|
||||
report.fail(remote.clone(), e);
|
||||
}
|
||||
for entry in entries {
|
||||
match download_target(dir, remote, &entry.path) {
|
||||
Some(local) if entry.is_dir => folders.push(local),
|
||||
Some(local) => jobs.push((entry.path, local)),
|
||||
None => report.skipped += 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Some(_)) => jobs.push((remote.clone(), top)),
|
||||
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let root = tokio::fs::canonicalize(dir).await?;
|
||||
for folder in &folders {
|
||||
if !stays_inside(&root, folder).await {
|
||||
report.fail(folder.display().to_string(), outside(folder));
|
||||
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
|
||||
report.fail(folder.display().to_string(), e.into());
|
||||
}
|
||||
}
|
||||
for (i, (remote, local)) in jobs.iter().enumerate() {
|
||||
if cancel.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
progress(remote, i, jobs.len());
|
||||
if !stays_inside(&root, local).await {
|
||||
report.fail(remote.clone(), outside(local));
|
||||
continue;
|
||||
}
|
||||
if let Some(parent) = local.parent()
|
||||
&& let Err(e) = tokio::fs::create_dir_all(parent).await
|
||||
{
|
||||
report.fail(remote.clone(), e.into());
|
||||
continue;
|
||||
}
|
||||
match fs.download(remote, local).await {
|
||||
Ok(()) => report.files += 1,
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let r = download_into(&fs, remotes, dir, cancel, progress).await;
|
||||
fs.close().await;
|
||||
Ok(report)
|
||||
r
|
||||
}
|
||||
|
||||
// --- save hook -----------------------------------------------------------------
|
||||
@@ -656,6 +601,75 @@ fn cache_key(connection: &FsConnection) -> String {
|
||||
}
|
||||
|
||||
/// Files and folders under remote folder `dir` (symlinked folders are not followed).
|
||||
/// `remotes` (folders recursively) into the local folder `dir`, each under its own name, without
|
||||
/// the remote path above it; existing files are replaced. Remote Host › Download to…, and the
|
||||
/// project view's Download to… in a remote project.
|
||||
pub async fn download_into(
|
||||
fs: &RemoteFs,
|
||||
remotes: &[String],
|
||||
dir: &Path,
|
||||
cancel: &CancellationToken,
|
||||
progress: &mut (dyn FnMut(&str, usize, usize) + Send),
|
||||
) -> IdeResult<TransferReport> {
|
||||
let mut report = TransferReport::default();
|
||||
let mut folders = Vec::new();
|
||||
let mut jobs = Vec::new();
|
||||
for remote in remotes {
|
||||
let Some(top) = download_target(dir, remote, remote) else {
|
||||
report.skipped += 1;
|
||||
continue;
|
||||
};
|
||||
match fs.stat(remote).await {
|
||||
Ok(Some(e)) if e.is_dir => {
|
||||
folders.push(top);
|
||||
let mut entries = Vec::new();
|
||||
if let Err(e) = remote_tree(fs, remote, cancel, &mut entries).await {
|
||||
report.fail(remote.clone(), e);
|
||||
}
|
||||
for entry in entries {
|
||||
match download_target(dir, remote, &entry.path) {
|
||||
Some(local) if entry.is_dir => folders.push(local),
|
||||
Some(local) => jobs.push((entry.path, local)),
|
||||
None => report.skipped += 1,
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(Some(_)) => jobs.push((remote.clone(), top)),
|
||||
Ok(None) => report.fail(remote.clone(), IdeError::not_found(format!("{remote} does not exist"))),
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
let root = tokio::fs::canonicalize(dir).await?;
|
||||
for folder in &folders {
|
||||
if !stays_inside(&root, folder).await {
|
||||
report.fail(folder.display().to_string(), outside(folder));
|
||||
} else if let Err(e) = tokio::fs::create_dir_all(folder).await {
|
||||
report.fail(folder.display().to_string(), e.into());
|
||||
}
|
||||
}
|
||||
for (i, (remote, local)) in jobs.iter().enumerate() {
|
||||
if cancel.is_cancelled() {
|
||||
break;
|
||||
}
|
||||
progress(remote, i, jobs.len());
|
||||
if !stays_inside(&root, local).await {
|
||||
report.fail(remote.clone(), outside(local));
|
||||
continue;
|
||||
}
|
||||
if let Some(parent) = local.parent()
|
||||
&& let Err(e) = tokio::fs::create_dir_all(parent).await
|
||||
{
|
||||
report.fail(remote.clone(), e.into());
|
||||
continue;
|
||||
}
|
||||
match fs.download(remote, local).await {
|
||||
Ok(()) => report.files += 1,
|
||||
Err(e) => report.fail(remote.clone(), e),
|
||||
}
|
||||
}
|
||||
Ok(report)
|
||||
}
|
||||
|
||||
async fn remote_tree(
|
||||
fs: &RemoteFs,
|
||||
dir: &str,
|
||||
|
||||
@@ -631,9 +631,11 @@ fn spring_boot_apps(root: &Path, build: &Path, out: &mut Vec<RunConfig>) {
|
||||
}
|
||||
}
|
||||
|
||||
/// The module has main sources, and its build applies the Spring Boot plugin: its own build
|
||||
/// file, or a build above it in `build` that applies it to its modules (a parent POM's
|
||||
/// `<build><plugins>`, Gradle's `subprojects` / `allprojects`).
|
||||
/// The module has main sources and Spring Boot on its classpath, as far as its build files
|
||||
/// tell: its own build, or a build above it in `build` that hands Spring Boot to its modules,
|
||||
/// references it (a dependency, the starter parent, the BOM or the plugin). A Maven module that
|
||||
/// depends on Spring Boot through a parent or another module is a Spring Boot application even
|
||||
/// without the packaging plugin; only `<pluginManagement>` alone doesn't count.
|
||||
fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
if !["java", "kotlin"].iter().any(|l| module.join("src/main").join(l).is_dir()) {
|
||||
return false;
|
||||
@@ -642,15 +644,19 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
if pom.contains("<packaging>pom</packaging>") {
|
||||
return false;
|
||||
}
|
||||
if pom.contains("spring-boot-maven-plugin") {
|
||||
if references_spring_boot(&without_plugin_management(&pom)) {
|
||||
return true;
|
||||
}
|
||||
} else if GRADLE_BUILDS.iter().filter_map(|n| read(&module.join(n))).any(|text| applies_boot_gradle_plugin(&text)) {
|
||||
} else if GRADLE_BUILDS
|
||||
.iter()
|
||||
.filter_map(|n| read(&module.join(n)))
|
||||
.any(|text| applies_boot_gradle_plugin(&text) || text.contains("org.springframework.boot:"))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
module.ancestors().skip(1).take_while(|dir| dir.starts_with(build)).any(|dir| {
|
||||
if let Some(pom) = read(&dir.join("pom.xml")) {
|
||||
return without_plugin_management(&pom).contains("spring-boot-maven-plugin");
|
||||
return references_spring_boot(&without_plugin_management(&pom));
|
||||
}
|
||||
GRADLE_BUILDS.iter().filter_map(|n| read(&dir.join(n))).any(|text| {
|
||||
(text.contains("subprojects") || text.contains("allprojects")) && applies_boot_gradle_plugin(&text)
|
||||
@@ -658,6 +664,14 @@ fn applies_spring_boot(build: &Path, module: &Path) -> bool {
|
||||
})
|
||||
}
|
||||
|
||||
/// A POM (without its `<pluginManagement>`) referencing Spring Boot: a dependency or the parent
|
||||
/// (`org.springframework.boot`), a starter, the BOM import or the plugin.
|
||||
fn references_spring_boot(pom: &str) -> bool {
|
||||
["org.springframework.boot", "spring-boot-starter", "spring-boot-dependencies", "spring-boot-maven-plugin"]
|
||||
.iter()
|
||||
.any(|m| pom.contains(m))
|
||||
}
|
||||
|
||||
/// A Gradle build applying the plugin (`id("org.springframework.boot")`, `apply plugin: '…'`),
|
||||
/// not only depending on Spring Boot (`org.springframework.boot:…`).
|
||||
fn applies_boot_gradle_plugin(text: &str) -> bool {
|
||||
|
||||
Loaded 100 of 839 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача