дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-16 06:35:40 +02:00
Порівняти коміти
7
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
69633262cf | ||
|
|
a5306bade3 | ||
|
|
aa8822d9a3 | ||
|
|
5fca9c9ed0 | ||
|
|
83805734bf | ||
|
|
0b3d1d67d9 | ||
|
|
53a26b95a4 |
No files matched your search
Бінарний файл не відображається.
|
Після Ширина: | Висота: | Розмір: 160 KiB |
Бінарний файл не відображається.
|
До Ширина: | Висота: | Розмір: 86 KiB |
Створено
+131
-6
@@ -199,7 +199,7 @@ dependencies = [
|
||||
"wayland-backend",
|
||||
"wayland-client",
|
||||
"wayland-protocols",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -5722,6 +5722,20 @@ dependencies = [
|
||||
"serde_repr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "mac-notification-sys"
|
||||
version = "0.6.15"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca"
|
||||
dependencies = [
|
||||
"cc",
|
||||
"log",
|
||||
"objc2 0.6.5",
|
||||
"objc2-foundation 0.3.2",
|
||||
"time",
|
||||
"uuid",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "mach2"
|
||||
version = "0.6.0"
|
||||
@@ -5994,6 +6008,20 @@ dependencies = [
|
||||
"windows-sys 0.60.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "notify-rust"
|
||||
version = "4.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57da5b5d3b7809bf71858da5a2818c3404ca4688c02c8abecdda0fcdec235df3"
|
||||
dependencies = [
|
||||
"futures-lite",
|
||||
"log",
|
||||
"mac-notification-sys",
|
||||
"serde",
|
||||
"tauri-winrt-notification",
|
||||
"zbus 6.3.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "notify-types"
|
||||
version = "2.1.0"
|
||||
@@ -6666,6 +6694,7 @@ dependencies = [
|
||||
"tauri-build",
|
||||
"tauri-plugin-dialog",
|
||||
"tauri-plugin-mcp-bridge",
|
||||
"tauri-plugin-notification",
|
||||
"tauri-plugin-opener",
|
||||
"tauri-plugin-single-instance",
|
||||
"tauri-plugin-updater",
|
||||
@@ -8153,7 +8182,7 @@ dependencies = [
|
||||
"once_cell",
|
||||
"serde",
|
||||
"sha2 0.11.1",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9429,6 +9458,26 @@ dependencies = [
|
||||
"windows-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-plugin-notification"
|
||||
version = "2.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "14a226bfb8189ec4ab2c1936e66330ad06c44d9f6c54a674338208491dee177f"
|
||||
dependencies = [
|
||||
"log",
|
||||
"notify-rust",
|
||||
"rand 0.10.3",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"serde_repr",
|
||||
"tauri",
|
||||
"tauri-plugin",
|
||||
"thiserror 2.0.21",
|
||||
"time",
|
||||
"url",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-plugin-opener"
|
||||
version = "2.7.2"
|
||||
@@ -9448,7 +9497,7 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
"url",
|
||||
"windows",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9464,7 +9513,7 @@ dependencies = [
|
||||
"tokio",
|
||||
"tracing",
|
||||
"windows-sys 0.61.2",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9647,6 +9696,17 @@ dependencies = [
|
||||
"toml 1.1.8+spec-1.1.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-winrt-notification"
|
||||
version = "0.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f37a6c354fd28fc9e322ed9bd47e3959576dad28c9d58ea1cf888cce1c7ccb36"
|
||||
dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
"windows",
|
||||
"windows-version",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tempfile"
|
||||
version = "3.27.0"
|
||||
@@ -12137,11 +12197,38 @@ dependencies = [
|
||||
"uuid",
|
||||
"windows-sys 0.61.2",
|
||||
"winnow 1.0.4",
|
||||
"zbus_macros",
|
||||
"zbus_macros 5.19.0",
|
||||
"zbus_names",
|
||||
"zvariant",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus"
|
||||
version = "6.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6b4aae740b23927ceabed962431abab2cdefb9f7f885e5bbab062da09bf580e4"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"bitflags 2.13.2",
|
||||
"endi",
|
||||
"futures-core",
|
||||
"hex",
|
||||
"libc",
|
||||
"ordered-stream",
|
||||
"rustix",
|
||||
"serde",
|
||||
"serde_repr",
|
||||
"socket2",
|
||||
"uds_windows",
|
||||
"uuid",
|
||||
"windows-sys 0.61.2",
|
||||
"winnow 1.0.4",
|
||||
"zbus_macros 6.3.0",
|
||||
"zbus_utils",
|
||||
"zcheapstr",
|
||||
"zruntime",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus-secret-service-keyring-store"
|
||||
version = "1.0.1"
|
||||
@@ -12150,7 +12237,7 @@ checksum = "74801d001b9e7729adb4f1825b67b398185fed424749aa3d8bacf70417137d9a"
|
||||
dependencies = [
|
||||
"keyring-core",
|
||||
"secret-service",
|
||||
"zbus",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -12168,6 +12255,18 @@ dependencies = [
|
||||
"zvariant_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_macros"
|
||||
version = "6.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37c9dd4beaf145c16fcb2902862f50da86e54aed13dd368ddf64a1d17e6b8529"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.9",
|
||||
"zbus_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_names"
|
||||
version = "4.3.5"
|
||||
@@ -12179,6 +12278,19 @@ dependencies = [
|
||||
"zvariant",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_utils"
|
||||
version = "6.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "af55e52da295311b368c45bcae221f020e28e97a2420360170ce389218e76ec7"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"serde",
|
||||
"syn 3.0.9",
|
||||
"winnow 1.0.4",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zcheapstr"
|
||||
version = "1.1.0"
|
||||
@@ -12335,6 +12447,19 @@ dependencies = [
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zruntime"
|
||||
version = "0.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ce6a55d4f521760475a30f7b96779508fe8c40dc834478709454dd1d5f0ebc72"
|
||||
dependencies = [
|
||||
"futures-core",
|
||||
"futures-io",
|
||||
"rustix",
|
||||
"socket2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zune-core"
|
||||
version = "0.5.3"
|
||||
|
||||
+1
-1
@@ -68,7 +68,7 @@ the [official plugins](plugins/official). The plugin API is still a preview.
|
||||
- [Discord](https://discord.gg/2Zy4yn7gP) — questions, feedback and release news.
|
||||
- WeChat group — scan to join:
|
||||
|
||||
<img src=".github/assets/wechat-group.png" alt="WeChat group QR code" width="200">
|
||||
<img src=".github/assets/wechat-group-3.png" alt="WeChat group QR code" width="200">
|
||||
|
||||
- Contributing: see [CONTRIBUTING.md](CONTRIBUTING.md) and the [contributor docs](https://openidea.sh/en/contribute/setup).
|
||||
|
||||
|
||||
+1
-1
@@ -68,7 +68,7 @@ Eklentileri Ayarlar › Eklentiler (Settings › Plugins) bölümünden kur ya d
|
||||
- [Discord](https://discord.gg/2Zy4yn7gP): sorular, geri bildirim ve sürüm haberleri.
|
||||
- WeChat grubu, katılmak için kodu okut:
|
||||
|
||||
<img src=".github/assets/wechat-group.png" alt="WeChat grubu QR kodu" width="200">
|
||||
<img src=".github/assets/wechat-group-3.png" alt="WeChat grubu QR kodu" width="200">
|
||||
|
||||
- Katkıda bulunmak için: [CONTRIBUTING.md](CONTRIBUTING.md) ve [katkıcı belgeleri](https://openidea.sh/en/contribute/setup).
|
||||
|
||||
|
||||
@@ -66,7 +66,7 @@ WebAssembly 组件运行;主题、图标主题和语言无需编写代码。
|
||||
- [Discord](https://discord.gg/2Zy4yn7gP):提问、反馈和版本发布消息。
|
||||
- 微信群,扫码加入:
|
||||
|
||||
<img src=".github/assets/wechat-group.png" alt="微信群二维码" width="200">
|
||||
<img src=".github/assets/wechat-group-3.png" alt="微信群二维码" width="200">
|
||||
|
||||
- 参与贡献:参见 [CONTRIBUTING.md](CONTRIBUTING.md) 和[贡献者文档](https://openidea.sh/zh/contribute/setup)。
|
||||
|
||||
|
||||
@@ -135,6 +135,8 @@ struct Shared {
|
||||
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
|
||||
idle_release_ms: AtomicU64,
|
||||
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
|
||||
/// Monotonic id for [`AgentEvent::Attention`] episodes.
|
||||
attention_seq: AtomicU64,
|
||||
}
|
||||
|
||||
/// What an agent offered in its last session, for the New Task page.
|
||||
@@ -417,6 +419,7 @@ impl AgentManager {
|
||||
probes: Mutex::new(HashMap::new()),
|
||||
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
|
||||
mcp_servers_hook: RwLock::new(None),
|
||||
attention_seq: AtomicU64::new(0),
|
||||
});
|
||||
shared.paths.catalogs.subscribe(&shared);
|
||||
let mut tasks = HashMap::new();
|
||||
@@ -1695,6 +1698,28 @@ impl Task {
|
||||
self.emit_task();
|
||||
}
|
||||
|
||||
fn emit_attention(&self, reason: AgentAttentionReason) {
|
||||
let n = self.shared.attention_seq.fetch_add(1, Ordering::Relaxed);
|
||||
let tag = match reason {
|
||||
AgentAttentionReason::Finished => "finished",
|
||||
AgentAttentionReason::Input => "input",
|
||||
AgentAttentionReason::Failed => "failed",
|
||||
};
|
||||
self.shared.emit(AgentEvent::Attention {
|
||||
task: self.id.clone(),
|
||||
event_id: format!("{}:{tag}:{n}", self.id),
|
||||
reason,
|
||||
});
|
||||
}
|
||||
|
||||
/// After NeedsInput + optional auto-approve: notify only when the user must still answer.
|
||||
fn emit_attention_if_input_pending(&self) {
|
||||
let waiting = !self.permissions.lock().is_empty() && self.state.lock().task.status == AgentStatus::NeedsInput;
|
||||
if waiting {
|
||||
self.emit_attention(AgentAttentionReason::Input);
|
||||
}
|
||||
}
|
||||
|
||||
fn persist(&self) {
|
||||
// Held from snapshot to rename, so saves land in order and none follows a delete.
|
||||
let deleted = self.deleted.lock();
|
||||
@@ -1797,8 +1822,11 @@ impl Task {
|
||||
}
|
||||
match (next, result) {
|
||||
(Some(queued), _) => prompt = queued.prompt,
|
||||
(None, Ok(_)) => {
|
||||
(None, Ok(stop)) => {
|
||||
self.set_status(AgentStatus::Ready, None);
|
||||
if stop != "cancelled" {
|
||||
self.emit_attention(AgentAttentionReason::Finished);
|
||||
}
|
||||
return self.release_when_idle();
|
||||
}
|
||||
(None, Err(failure)) => return self.fail(failure),
|
||||
@@ -1869,6 +1897,7 @@ impl Task {
|
||||
}
|
||||
None => self.set_status(AgentStatus::Failed, Some(failure.message)),
|
||||
}
|
||||
self.emit_attention(AgentAttentionReason::Failed);
|
||||
}
|
||||
|
||||
/// Adds `prompt` to the running turn when the agent takes that; gives it back otherwise.
|
||||
@@ -2500,6 +2529,7 @@ impl Task {
|
||||
self.permissions.lock().insert(id, tx);
|
||||
self.set_status(AgentStatus::NeedsInput, None);
|
||||
self.approve_pending();
|
||||
self.emit_attention_if_input_pending();
|
||||
|
||||
let answer = rx.recv().ok().flatten();
|
||||
let answers = answer
|
||||
@@ -2583,6 +2613,7 @@ impl Task {
|
||||
});
|
||||
self.permissions.lock().insert(id, tx);
|
||||
self.set_status(AgentStatus::NeedsInput, None);
|
||||
self.emit_attention_if_input_pending();
|
||||
let reply = rx.recv().ok().flatten();
|
||||
let (response, chosen) = elicitation::answer(&form, reply.as_deref());
|
||||
self.settle(entry, chosen);
|
||||
|
||||
@@ -5,6 +5,15 @@ use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// Why a task needs the user's attention (native / in-app notify).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentAttentionReason {
|
||||
Finished,
|
||||
Input,
|
||||
Failed,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentStatus {
|
||||
@@ -666,6 +675,12 @@ pub enum AgentEvent {
|
||||
},
|
||||
/// The installed or configured agent providers changed.
|
||||
Providers,
|
||||
/// The task needs attention once (finished turn, explicit input, or failure).
|
||||
Attention {
|
||||
task: String,
|
||||
event_id: String,
|
||||
reason: AgentAttentionReason,
|
||||
},
|
||||
}
|
||||
|
||||
pub use ide_core::settings::{AgentMcpServer, McpTransport};
|
||||
|
||||
@@ -3619,3 +3619,177 @@ async fn ephemeral_tasks_deny_write_permissions() {
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
fn attention_reasons(events: &[AgentEvent]) -> Vec<AgentAttentionReason> {
|
||||
events
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
AgentEvent::Attention { reason, .. } => Some(*reason),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// `wait_for(Ready/Failed/…)` can return after status is written but before the
|
||||
/// following `emit_attention` runs on the agent thread — poll the sink instead.
|
||||
async fn wait_for_attention(events: &Mutex<Vec<AgentEvent>>, reason: AgentAttentionReason) {
|
||||
for _ in 0..500 {
|
||||
if attention_reasons(&events.lock()).contains(&reason) {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
panic!("never saw Attention::{reason:?}: {:?}", *events.lock());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_finished_not_cancelled() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
|
||||
let done = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &done.id, AgentStatus::Ready).await;
|
||||
wait_for_attention(&events, AgentAttentionReason::Finished).await;
|
||||
events.lock().clear();
|
||||
|
||||
let cancelled = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("wait"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &cancelled.id, AgentStatus::Running).await;
|
||||
mgr.cancel(&cancelled.id, None).unwrap();
|
||||
wait_for(&mgr, &cancelled.id, AgentStatus::Ready).await;
|
||||
// Give a late Finished emission a chance; cancellation must not produce one.
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert!(
|
||||
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Finished),
|
||||
"cancelled must not notify finished: {:?}",
|
||||
*events.lock()
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_failed() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent {
|
||||
request_error: Some((codes::INTERNAL_ERROR, "boom".into())),
|
||||
auth_on_new: true,
|
||||
..Default::default()
|
||||
});
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Fix"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
|
||||
wait_for_attention(&events, AgentAttentionReason::Failed).await;
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_input_not_auto_bypass() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
|
||||
let asked = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Fix"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &asked.id, AgentStatus::NeedsInput).await;
|
||||
wait_for_attention(&events, AgentAttentionReason::Input).await;
|
||||
events.lock().clear();
|
||||
mgr.cancel(&asked.id, None).unwrap();
|
||||
wait_for(&mgr, &asked.id, AgentStatus::Ready).await;
|
||||
|
||||
let bypassed = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Fix"),
|
||||
provider: "cursor".into(),
|
||||
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &bypassed.id, AgentStatus::Ready).await;
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert!(
|
||||
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Input),
|
||||
"auto-bypass must not notify input: {:?}",
|
||||
*events.lock()
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_not_emitted_on_restore() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
|
||||
let restored = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
let tasks = restored.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
assert!(tasks.iter().any(|t| t.id == task.id));
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert!(attention_reasons(&events.lock()).is_empty(), "snapshot restore must not re-notify: {:?}", *events.lock());
|
||||
restored.shutdown();
|
||||
}
|
||||
@@ -71,6 +71,8 @@ pub struct Settings {
|
||||
pub scopes: Vec<NamedScope>,
|
||||
/// Appearance & Behavior › File Colors.
|
||||
pub file_colors: FileColorSettings,
|
||||
/// Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes.
|
||||
pub database: DatabaseSettings,
|
||||
/// Plugin settings (`[contributes.settings]`): plugin id → its values by key.
|
||||
#[specta(type = BTreeMap<String, BTreeMap<String, specta_typescript::Unknown>>)]
|
||||
pub plugins: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
|
||||
@@ -508,6 +510,7 @@ impl Default for Settings {
|
||||
agent_security: AgentSecuritySettings::default(),
|
||||
scopes: Vec::new(),
|
||||
file_colors: FileColorSettings::default(),
|
||||
database: DatabaseSettings::default(),
|
||||
plugins: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
@@ -647,13 +650,20 @@ impl Default for DateFormatSettings {
|
||||
pub struct NotificationSettings {
|
||||
pub balloons: bool,
|
||||
pub sound: bool,
|
||||
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
|
||||
#[serde(default = "default_true")]
|
||||
pub system_notifications: bool,
|
||||
/// Group id → display; groups not listed use their default.
|
||||
pub groups: BTreeMap<String, NotificationGroupSettings>,
|
||||
}
|
||||
|
||||
fn default_true() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
impl Default for NotificationSettings {
|
||||
fn default() -> Self {
|
||||
Self { balloons: true, sound: false, groups: BTreeMap::new() }
|
||||
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -241,6 +241,30 @@ impl Default for LogLevelColors {
|
||||
}
|
||||
}
|
||||
|
||||
/// Database settings: Query Execution and SQL Resolution Scopes.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct DatabaseSettings {
|
||||
/// A console's result sets show under the statements that produced them, in the editor,
|
||||
/// instead of in the Services view's result tabs.
|
||||
pub in_editor_results: bool,
|
||||
/// Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
|
||||
/// resolves against (completion, inspections, navigation), most specific path first.
|
||||
pub resolution_scopes: Vec<SqlResolutionScope>,
|
||||
}
|
||||
|
||||
/// One row of SQL Resolution Scopes.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct SqlResolutionScope {
|
||||
/// Project-relative file or folder, `/`-separated; empty for the whole project.
|
||||
pub path: String,
|
||||
/// Data source id.
|
||||
pub data_source: String,
|
||||
/// Schema unqualified names resolve in; empty for the data source's default.
|
||||
pub schema: String,
|
||||
}
|
||||
|
||||
/// Build, Execution, Deployment › Console.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
|
||||
@@ -120,6 +120,12 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
|
||||
"stdio",
|
||||
"Install GDB 14 or newer (apt install gdb, dnf install gdb, brew install gdb)",
|
||||
),
|
||||
"unity" => cfg(
|
||||
"unity-debug",
|
||||
&[],
|
||||
"stdio",
|
||||
"Install Unity Debugger in Settings > Language Servers, or configure the unity-debug tool path",
|
||||
),
|
||||
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
|
||||
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
|
||||
"java-debug" => cfg(
|
||||
|
||||
@@ -12,6 +12,7 @@ use std::path::Path;
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AttachKind {
|
||||
Unity,
|
||||
Java,
|
||||
Node,
|
||||
Python,
|
||||
|
||||
@@ -19,6 +19,7 @@ mod jvm_memory;
|
||||
pub mod kotlin;
|
||||
pub mod kotlin_lsp;
|
||||
mod session;
|
||||
pub mod unity;
|
||||
|
||||
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
|
||||
use connection::{Connection, DapError};
|
||||
@@ -1121,6 +1122,16 @@ impl DebugManager {
|
||||
let _ = tokio::time::timeout(INIT_TIMEOUT, initialized.wait_for(|v| *v)).await;
|
||||
}
|
||||
|
||||
if s.adapter == "unity" {
|
||||
if launch_result.is_none()
|
||||
&& let Some(launch) = launch.as_mut()
|
||||
{
|
||||
launch.await?;
|
||||
launch_result = Some(());
|
||||
}
|
||||
unity::wait_for_threads(s).await?;
|
||||
}
|
||||
|
||||
// A fresh adapter has no breakpoints, so a file with none enabled needs no request; the
|
||||
// others go out together, as VS Code sends them, instead of one round trip per file.
|
||||
let (files, idle): (Vec<_>, Vec<_>) = self
|
||||
@@ -1202,6 +1213,10 @@ impl DebugManager {
|
||||
if let Some(link) = s.jdwp_link.lock().as_ref() {
|
||||
link.release();
|
||||
}
|
||||
if s.adapter == "unity" {
|
||||
unity::settle_startup(s).await;
|
||||
s.emit(ide_core::event::DebugEvent::Initialized);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -17,7 +17,7 @@ use std::process::Stdio;
|
||||
use std::sync::Arc;
|
||||
use std::sync::Weak;
|
||||
use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
|
||||
use std::time::Duration;
|
||||
use std::time::{Duration, Instant};
|
||||
use tokio::io::{AsyncRead, AsyncReadExt};
|
||||
use tokio::process::Child;
|
||||
use tokio::sync::{mpsc, watch};
|
||||
@@ -116,6 +116,7 @@ pub(crate) struct Session {
|
||||
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
|
||||
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
|
||||
pub(crate) quirks: kotlin_lsp::Quirks,
|
||||
pub(crate) unity_startup_activity: Mutex<Instant>,
|
||||
}
|
||||
|
||||
/// Which threads of the program are suspended: each from its `stopped` event until a
|
||||
@@ -270,6 +271,7 @@ impl Session {
|
||||
kotlin_mirror: Mutex::new(None),
|
||||
jvm_memory: tokio::sync::Mutex::default(),
|
||||
quirks: kotlin_lsp::Quirks::default(),
|
||||
unity_startup_activity: Mutex::new(Instant::now()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -716,6 +718,15 @@ pub(crate) async fn event_loop(
|
||||
}
|
||||
|
||||
async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut body: Value) {
|
||||
if s.adapter == "unity"
|
||||
&& event == "output"
|
||||
&& body
|
||||
.get("output")
|
||||
.and_then(Value::as_str)
|
||||
.is_some_and(|text| text.starts_with("Loaded assembly:") || text.starts_with("Resolved pending breakpoint"))
|
||||
{
|
||||
*s.unity_startup_activity.lock() = Instant::now();
|
||||
}
|
||||
if let Some(mirror) = s.kotlin_mirror.lock().as_ref() {
|
||||
mirror.translate(&mut body);
|
||||
}
|
||||
@@ -724,7 +735,9 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
match event {
|
||||
"initialized" => {
|
||||
s.initialized.send_replace(true);
|
||||
s.emit(DebugEvent::Initialized);
|
||||
if s.adapter != "unity" {
|
||||
s.emit(DebugEvent::Initialized);
|
||||
}
|
||||
}
|
||||
"stopped" => {
|
||||
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
|
||||
|
||||
@@ -158,6 +158,7 @@ struct Script {
|
||||
/// `launch`, and a `configurationDone` sent while it runs is refused with `notStopped`.
|
||||
gdb15_starts_at_launch: bool,
|
||||
launch_after_configuration: bool,
|
||||
empty_thread_responses: usize,
|
||||
/// Requests of the adapter's own (js-debug's `setCustomBreakpoints`…) answered with an empty body.
|
||||
accept: &'static [&'static str],
|
||||
/// Requests of the adapter's own answered with a body and followed by events.
|
||||
@@ -198,6 +199,7 @@ impl Default for Script {
|
||||
close_during_startup: false,
|
||||
gdb15_starts_at_launch: false,
|
||||
launch_after_configuration: false,
|
||||
empty_thread_responses: 0,
|
||||
accept: &[],
|
||||
custom: None,
|
||||
}
|
||||
@@ -244,6 +246,8 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
let mut held: Vec<Value> = Vec::new();
|
||||
let mut stopped = false;
|
||||
let mut running = false;
|
||||
let mut thread_requests = 0;
|
||||
let mut unity = false;
|
||||
macro_rules! send {
|
||||
($v:expr) => {{
|
||||
let mut v: Value = $v;
|
||||
@@ -268,13 +272,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
}
|
||||
match msg["command"].as_str().unwrap_or_default() {
|
||||
"initialize" => {
|
||||
unity = msg["arguments"]["adapterID"] == "unity";
|
||||
if let Some(delay) = script.delay_initialize {
|
||||
tokio::time::sleep(delay).await;
|
||||
}
|
||||
ok!(
|
||||
msg,
|
||||
json!({
|
||||
"supportsConfigurationDoneRequest": true,
|
||||
"supportsConfigurationDoneRequest": !unity,
|
||||
"supportsCompletionsRequest": true,
|
||||
"supportsTerminateRequest": script.supports_terminate,
|
||||
"supportsSetVariable": true,
|
||||
@@ -293,8 +298,15 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
// defers it sends late).
|
||||
send!(json!({"type": "event", "event": "initialized"}));
|
||||
}
|
||||
if unity {
|
||||
send!(json!({"type": "event", "event": "initialized"}));
|
||||
}
|
||||
}
|
||||
"launch" | "attach" => {
|
||||
if unity {
|
||||
ok!(msg, Value::Null);
|
||||
continue;
|
||||
}
|
||||
if script.gdb15_starts_at_launch {
|
||||
// GDB 15 starts the program here and answers `launch` right away.
|
||||
running = true;
|
||||
@@ -448,7 +460,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
ok!(msg, json!({"threads": [{"id": 1, "name": "\"main\"@1"}]}));
|
||||
}
|
||||
"threads" => ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]})),
|
||||
"threads" => {
|
||||
thread_requests += 1;
|
||||
if thread_requests <= script.empty_thread_responses {
|
||||
ok!(msg, json!({"threads": []}));
|
||||
} else {
|
||||
ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]}));
|
||||
}
|
||||
}
|
||||
"stackTrace" => ok!(
|
||||
msg,
|
||||
json!({"stackFrames": [
|
||||
@@ -878,6 +897,32 @@ async fn stop_terminates_and_disconnects() {
|
||||
assert!(h.manager.threads(id).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unity_attach_waits_for_mono_and_disconnects_without_terminating_editor() {
|
||||
let h = harness(Script { empty_thread_responses: 2, ..Script::default() });
|
||||
h.manager.set_breakpoints(PathBuf::from("/p/a.cs"), vec![bp(4)]).await.unwrap();
|
||||
let start = h.start(LaunchConfig {
|
||||
adapter: "unity".into(),
|
||||
request: "attach".into(),
|
||||
program: None,
|
||||
extra_json: Some(json!({ "name": "Unity Editor (42)", "__exceptionOptions": [] }).to_string()),
|
||||
..config()
|
||||
});
|
||||
let ready = async {
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
|
||||
let commands = h.commands();
|
||||
let before_breakpoints = commands.iter().take_while(|c| *c != "setBreakpoints");
|
||||
assert!(before_breakpoints.filter(|c| *c == "threads").count() >= 3);
|
||||
assert!(commands.iter().any(|c| c == "setBreakpoints"));
|
||||
};
|
||||
let (id, ()) = tokio::join!(start, ready);
|
||||
let id = id.unwrap();
|
||||
assert_eq!(h.request("attach")["arguments"]["name"], "Unity Editor (42)");
|
||||
h.manager.stop(id).await.unwrap();
|
||||
assert!(!h.commands().iter().any(|c| c == "launch" || c == "terminate"));
|
||||
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn concurrent_sessions_are_independent() {
|
||||
let h = harness(Script::default());
|
||||
|
||||
@@ -0,0 +1,187 @@
|
||||
//! Lists the Unity Editors to attach to through UnityDebug's discovery (`unity-debug list`).
|
||||
|
||||
use crate::{
|
||||
adapter,
|
||||
attach::{AttachKind, AttachableProcess},
|
||||
};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::{path::PathBuf, process::Stdio, time::Duration};
|
||||
|
||||
/// Waits until Mono reports its threads.
|
||||
pub(crate) async fn wait_for_threads(session: &crate::session::Session) -> IdeResult<()> {
|
||||
tokio::time::timeout(Duration::from_secs(20), async {
|
||||
loop {
|
||||
let body = session.conn.request_timeout("threads", serde_json::json!({}), Duration::from_secs(5)).await?;
|
||||
if body.get("threads").and_then(serde_json::Value::as_array).is_some_and(|t| !t.is_empty()) {
|
||||
return Ok(());
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.map_err(|_| {
|
||||
IdeError::unavailable(
|
||||
"Unity debugger did not become ready. Enable Editor Attaching and Debug Mode in Unity, then retry.",
|
||||
)
|
||||
})?
|
||||
}
|
||||
|
||||
// Mono binds breakpoints asynchronously and resumes threads itself during startup: wait for that burst to end.
|
||||
pub(crate) async fn settle_startup(session: &crate::session::Session) {
|
||||
*session.unity_startup_activity.lock() = std::time::Instant::now();
|
||||
let _ = tokio::time::timeout(Duration::from_secs(3), async {
|
||||
while session.unity_startup_activity.lock().elapsed() < Duration::from_secs(1) {
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
})
|
||||
.await;
|
||||
}
|
||||
|
||||
pub fn require_runtime(cwd: &std::path::Path) -> IdeResult<()> {
|
||||
if cfg!(unix) && ide_core::tool_path::find_command("mono", &ide_core::tool_path::search_path(), cwd).is_none() {
|
||||
return Err(IdeError::unavailable(
|
||||
"Unity Debugger requires Mono. Install Mono, make sure mono is on PATH, then refresh the Unity process list.",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
const NOT_INSTALLED: &str = "debug adapter `unity` not found. Install Unity Debugger in Settings > Language Servers or configure the unity-debug tool path";
|
||||
|
||||
pub async fn editors(command: Option<String>, cwd: PathBuf) -> IdeResult<Vec<AttachableProcess>> {
|
||||
require_runtime(&cwd)?;
|
||||
let command = command.unwrap_or_else(|| "unity-debug".into());
|
||||
let lookup = command.clone();
|
||||
let dir = cwd.clone();
|
||||
let binary = tokio::task::spawn_blocking(move || adapter::resolve_binary(&lookup, &dir))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
.ok_or_else(|| IdeError::unavailable(NOT_INSTALLED))?;
|
||||
let mut cmd = tokio::process::Command::new(binary);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
cmd.arg("list")
|
||||
.current_dir(&cwd)
|
||||
.env("PATH", ide_core::tool_path::search_path())
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.kill_on_drop(true);
|
||||
let out = tokio::time::timeout(Duration::from_secs(15), cmd.output())
|
||||
.await
|
||||
.map_err(|_| {
|
||||
IdeError::unavailable("Unity process discovery timed out. Check that Unity Editor is responsive.")
|
||||
})?
|
||||
.map_err(|e| IdeError::unavailable(format!("Cannot start Unity process discovery: {e}")))?;
|
||||
if !out.status.success() {
|
||||
return Err(IdeError::unavailable(format!(
|
||||
"Unity process discovery failed: {}",
|
||||
String::from_utf8_lossy(&out.stderr).trim()
|
||||
)));
|
||||
}
|
||||
let mut rows = parse_editors(&String::from_utf8_lossy(&out.stdout));
|
||||
#[cfg(windows)]
|
||||
if !rows.is_empty() {
|
||||
match editor_process_ids() {
|
||||
Ok(editors) => rows.retain(|p| editors.contains(&p.pid)),
|
||||
Err(error) => tracing::warn!(%error, "Unity process filtering failed; using adapter discovery results"),
|
||||
}
|
||||
}
|
||||
// The Editor of the open project comes first; the user picks which one to attach to.
|
||||
let path = cwd.join("Library/EditorInstance.json");
|
||||
let pid = std::fs::File::open(path).ok().and_then(|file| {
|
||||
use std::io::Read;
|
||||
let json: serde_json::Value = serde_json::from_reader(file.take(4096)).ok()?;
|
||||
json.get("process_id")?.as_u64().and_then(|n| u32::try_from(n).ok())
|
||||
});
|
||||
for row in &mut rows {
|
||||
if Some(row.pid) == pid {
|
||||
row.command_line = cwd.to_string_lossy().into_owned();
|
||||
}
|
||||
}
|
||||
rows.sort_by_key(|p| Some(p.pid) != pid);
|
||||
Ok(rows)
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn editor_process_ids() -> IdeResult<std::collections::HashSet<u32>> {
|
||||
use std::collections::HashMap;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{CloseHandle, INVALID_HANDLE_VALUE},
|
||||
System::Diagnostics::ToolHelp::{
|
||||
CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
|
||||
},
|
||||
};
|
||||
|
||||
let mut unity = HashMap::new();
|
||||
// The adapter also finds the asset import worker processes: keep the Unity processes whose parent isn't Unity.
|
||||
unsafe {
|
||||
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
||||
if snapshot == INVALID_HANDLE_VALUE {
|
||||
return Err(std::io::Error::last_os_error().into());
|
||||
}
|
||||
let mut entry = PROCESSENTRY32W { dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32, ..std::mem::zeroed() };
|
||||
let mut found = Process32FirstW(snapshot, &mut entry);
|
||||
if found == 0 {
|
||||
let error = std::io::Error::last_os_error();
|
||||
CloseHandle(snapshot);
|
||||
return Err(error.into());
|
||||
}
|
||||
while found != 0 {
|
||||
let end = entry.szExeFile.iter().position(|c| *c == 0).unwrap_or(entry.szExeFile.len());
|
||||
let name = String::from_utf16_lossy(&entry.szExeFile[..end]);
|
||||
if name.eq_ignore_ascii_case("Unity.exe") {
|
||||
unity.insert(entry.th32ProcessID, entry.th32ParentProcessID);
|
||||
}
|
||||
found = Process32NextW(snapshot, &mut entry);
|
||||
}
|
||||
CloseHandle(snapshot);
|
||||
}
|
||||
Ok(unity.iter().filter_map(|(&pid, parent)| (!unity.contains_key(parent)).then_some(pid)).collect())
|
||||
}
|
||||
|
||||
pub fn parse_editors(output: &str) -> Vec<AttachableProcess> {
|
||||
let mut editors = Vec::new();
|
||||
for line in output.lines() {
|
||||
let line = line.trim().trim_start_matches('\u{feff}');
|
||||
if !line.starts_with("Unity Editor (") {
|
||||
continue;
|
||||
}
|
||||
// 3.0.1 prints `Unity Editor (Unity) (123)`; later versions append the project name.
|
||||
let Some((name, pid, project)) = line.match_indices(" (").find_map(|(at, _)| {
|
||||
let (id, project) = line[at + 2..].split_once(')')?;
|
||||
let pid = id.parse::<u32>().ok().filter(|n| *n > 0)?;
|
||||
Some((&line[..at], pid, project))
|
||||
}) else {
|
||||
continue;
|
||||
};
|
||||
if editors.iter().any(|p: &AttachableProcess| p.pid == pid) {
|
||||
continue;
|
||||
}
|
||||
editors.push(AttachableProcess {
|
||||
pid,
|
||||
name: "Unity Editor".into(),
|
||||
command_line: if project.trim().is_empty() { name.into() } else { project.trim().into() },
|
||||
kind: AttachKind::Unity,
|
||||
adapter: "unity".into(),
|
||||
host: None,
|
||||
port: None,
|
||||
});
|
||||
}
|
||||
editors.sort_by(|a, b| a.command_line.cmp(&b.command_line).then(a.pid.cmp(&b.pid)));
|
||||
editors
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn parses_editor_ids_and_projects_without_mistaking_players_or_logs_for_editors() {
|
||||
let rows = parse_editors(
|
||||
"\u{feff}Unity Editor (Unity) (42) Game (Test)\r\nUnity Editor (7) My Game\nUnity Editor (42) duplicate\nWindowsPlayer (123) Player\nUnity Hub (44)\nUnity Editor (invalid)\nUnity Editor (0)\nlog text",
|
||||
);
|
||||
assert_eq!(rows.len(), 2);
|
||||
assert_eq!((rows[0].pid, rows[0].command_line.as_str()), (42, "Game (Test)"));
|
||||
assert_eq!(rows[1].pid, 7);
|
||||
assert!(rows.iter().all(|p| p.kind == AttachKind::Unity && p.adapter == "unity"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
//! Attaches to a real Unity Editor, with its own temporary project and Editor instance.
|
||||
//! OPENIDEA_UNITY_EDITOR=<Unity.exe> OPENIDEA_UNITY_ADAPTER=<UnityDebug.exe>
|
||||
//! cargo test -p ide-dap --test unity -- --ignored --nocapture
|
||||
|
||||
use ide_core::{IdeEvent, SharedSink, event::DebugEvent};
|
||||
use ide_dap::{Breakpoint, DebugManager, LaunchConfig, SessionOwner, StepKind};
|
||||
use ide_language::LanguageRegistry;
|
||||
use parking_lot::Mutex;
|
||||
use std::{collections::BTreeMap, path::PathBuf, sync::Arc, time::Duration};
|
||||
|
||||
const SCRIPT: &str = r#"using System.IO;
|
||||
using UnityEditor;
|
||||
using UnityEngine;
|
||||
[InitializeOnLoad]
|
||||
public static class OpenIdeaAttachProbe
|
||||
{
|
||||
static readonly string Root = Directory.GetParent(Application.dataPath).FullName;
|
||||
static OpenIdeaAttachProbe()
|
||||
{
|
||||
EditorApplication.update += Tick;
|
||||
}
|
||||
static void Tick()
|
||||
{
|
||||
if (EditorApplication.isCompiling || EditorApplication.isUpdating) return;
|
||||
if (!File.Exists(Path.Combine(Root, "ready")))
|
||||
File.WriteAllText(Path.Combine(Root, "ready"), System.Diagnostics.Process.GetCurrentProcess().Id.ToString());
|
||||
if (File.Exists(Path.Combine(Root, "exit"))) { EditorApplication.Exit(0); return; }
|
||||
if (!File.Exists(Path.Combine(Root, "go"))) return;
|
||||
File.Delete(Path.Combine(Root, "go"));
|
||||
int result = Hit(41);
|
||||
File.WriteAllText(Path.Combine(Root, "done"), result.ToString());
|
||||
}
|
||||
static int Hit(int seed)
|
||||
{
|
||||
int answer = seed + 1;
|
||||
return answer;
|
||||
}
|
||||
}
|
||||
"#;
|
||||
|
||||
async fn stopped(events: &Mutex<Vec<IdeEvent>>, expected_reason: &str) -> i64 {
|
||||
for _ in 0..600 {
|
||||
if let Some(thread) = events.lock().iter().find_map(|e| match e {
|
||||
IdeEvent::Debug { event: DebugEvent::Stopped { thread_id, reason, .. }, .. }
|
||||
if reason == expected_reason =>
|
||||
{
|
||||
Some(*thread_id)
|
||||
}
|
||||
_ => None,
|
||||
}) {
|
||||
return thread;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
let events = events.lock();
|
||||
panic!("No breakpoint/step event: {:?}", &events[events.len().saturating_sub(16)..]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
#[ignore = "needs a licensed Unity Editor and the Unity DAP adapter"]
|
||||
async fn real_editor_attach_breakpoint_step_variables_and_detach() {
|
||||
let editor = std::env::var("OPENIDEA_UNITY_EDITOR").expect("OPENIDEA_UNITY_EDITOR");
|
||||
let adapter = std::env::var("OPENIDEA_UNITY_ADAPTER").expect("OPENIDEA_UNITY_ADAPTER");
|
||||
let target = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target").canonicalize().unwrap();
|
||||
// Keep the Editor log for diagnosing a failure.
|
||||
let root = tempfile::Builder::new().prefix("unity-dap-smoke-").tempdir_in(target).unwrap().keep();
|
||||
let root = root.to_string_lossy().trim_start_matches(r"\\?\").replace('\\', "/");
|
||||
let root = PathBuf::from(root);
|
||||
std::fs::create_dir_all(root.join("Assets/Editor")).unwrap();
|
||||
std::fs::create_dir(root.join("ProjectSettings")).unwrap();
|
||||
std::fs::create_dir(root.join("Packages")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("ProjectSettings/ProjectVersion.txt"),
|
||||
format!(
|
||||
"m_EditorVersion: {}\n",
|
||||
PathBuf::from(&editor).ancestors().nth(2).and_then(|p| p.file_name()).unwrap().to_string_lossy()
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(root.join("Packages/manifest.json"), r#"{"dependencies":{}}"#).unwrap();
|
||||
let source = root.join("Assets/Editor/OpenIdeaAttachProbe.cs");
|
||||
std::fs::write(&source, SCRIPT).unwrap();
|
||||
let mut command = tokio::process::Command::new(&editor);
|
||||
ide_core::process::prepare(command.as_std_mut());
|
||||
// The test project has no packages: skip the package manager.
|
||||
command
|
||||
.args(["-batchmode", "-nographics", "-noUpm", "-debugCodeOptimization", "-projectPath"])
|
||||
.arg(&root)
|
||||
.arg("-logFile")
|
||||
.arg(root.join("Editor.log"))
|
||||
.current_dir(&root)
|
||||
.kill_on_drop(true);
|
||||
let mut child = command.spawn().unwrap();
|
||||
let pid = child.id().unwrap();
|
||||
eprintln!("Isolated Unity pid {pid}, project {}", root.display());
|
||||
for _ in 0..1200 {
|
||||
if root.join("ready").exists() {
|
||||
break;
|
||||
}
|
||||
assert!(child.try_wait().unwrap().is_none(), "Unity exited; inspect {}/Editor.log", root.display());
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
assert!(root.join("ready").exists(), "Editor failed to load the test script");
|
||||
let rows = ide_dap::unity::editors(Some(adapter.clone()), root.clone()).await.unwrap();
|
||||
assert!(rows.iter().any(|p| p.pid == pid), "test Editor absent: {rows:?}");
|
||||
let events: Arc<Mutex<Vec<IdeEvent>>> = Arc::default();
|
||||
let saved = events.clone();
|
||||
let sink: SharedSink = Arc::new(move |event| saved.lock().push(event));
|
||||
let manager = DebugManager::new(Arc::new(LanguageRegistry::from_configs(Vec::new())));
|
||||
let line = SCRIPT.lines().position(|l| l.contains("int answer =")).unwrap() as u32;
|
||||
manager
|
||||
.set_breakpoints(
|
||||
source.clone(),
|
||||
vec![Breakpoint { line, condition: None, hit_condition: None, log_message: None, enabled: true }],
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let start = || {
|
||||
manager.start_with(
|
||||
LaunchConfig {
|
||||
name: format!("Unity Editor ({pid})"),
|
||||
adapter: "unity".into(),
|
||||
request: "attach".into(),
|
||||
program: None,
|
||||
args: vec![],
|
||||
cwd: Some(root.clone().into()),
|
||||
env: BTreeMap::new(),
|
||||
extra_json: Some(
|
||||
serde_json::json!({ "name": format!("Unity Editor ({pid})"), "__exceptionOptions": [] })
|
||||
.to_string(),
|
||||
),
|
||||
},
|
||||
SessionOwner::new("smoke", sink.clone()),
|
||||
|_| Some(adapter.clone()),
|
||||
)
|
||||
};
|
||||
let session = start().await.unwrap();
|
||||
eprintln!("Attached; breakpoint states: {:?}", manager.breakpoint_states(&source));
|
||||
// Mono is ready to run once the start returns.
|
||||
assert!(!manager.threads(session).await.unwrap().is_empty());
|
||||
std::fs::write(root.join("go"), "").unwrap();
|
||||
let thread = stopped(&events, "breakpoint").await;
|
||||
let frames = manager.stack_trace(session, thread).await.unwrap();
|
||||
assert!(!frames.is_empty(), "Empty breakpoint stack: {:?}", events.lock());
|
||||
assert_eq!(frames[0].line, line);
|
||||
let scopes = manager.scopes(session, frames[0].id).await.unwrap();
|
||||
let variables = manager.variables(session, scopes[0].variables_reference).await.unwrap();
|
||||
assert!(variables.iter().any(|v| v.name == "seed" && v.value == "41"), "{variables:?}");
|
||||
assert_eq!(manager.evaluate(session, Some(frames[0].id), "seed + 1".into()).await.unwrap().value, "42");
|
||||
events.lock().clear();
|
||||
manager.step(session, thread, StepKind::Over).await.unwrap();
|
||||
let thread = stopped(&events, "step").await;
|
||||
let frames = manager.stack_trace(session, thread).await.unwrap();
|
||||
assert!(!frames.is_empty(), "Empty step stack: {:?}", events.lock());
|
||||
assert!(frames[0].line > line);
|
||||
// Detaching at a breakpoint resumes the Editor.
|
||||
manager.stop(session).await.unwrap();
|
||||
verify_resumed(&root, &mut child).await;
|
||||
|
||||
// Attaching again to the same Editor hits the existing breakpoint.
|
||||
std::fs::remove_file(root.join("done")).unwrap();
|
||||
events.lock().clear();
|
||||
let session = start().await.unwrap_or_else(|error| {
|
||||
let events = events.lock();
|
||||
panic!("Reattach failed: {error:?}, recent events: {:?}", &events[events.len().saturating_sub(12)..]);
|
||||
});
|
||||
std::fs::write(root.join("go"), "").unwrap();
|
||||
let thread = stopped(&events, "breakpoint").await;
|
||||
assert_eq!(manager.stack_trace(session, thread).await.unwrap()[0].line, line);
|
||||
manager.stop(session).await.unwrap();
|
||||
verify_resumed(&root, &mut child).await;
|
||||
std::fs::write(root.join("exit"), "").unwrap();
|
||||
assert!(tokio::time::timeout(Duration::from_secs(30), child.wait()).await.unwrap().unwrap().success());
|
||||
eprintln!("Verified discovery, attachment, breakpoint, locals, evaluation, step, detach and reattachment");
|
||||
}
|
||||
|
||||
async fn verify_resumed(root: &std::path::Path, child: &mut tokio::process::Child) {
|
||||
let path = root.join("done");
|
||||
for _ in 0..100 {
|
||||
assert!(child.try_wait().unwrap().is_none(), "disconnect terminated the Unity Editor");
|
||||
if std::fs::read_to_string(&path).is_ok_and(|text| text == "42") {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
panic!("Unity did not complete the script after disconnect: {:?}", std::fs::read_to_string(path));
|
||||
}
|
||||
@@ -650,28 +650,52 @@ fn structure_plan(
|
||||
kind: BuildKind,
|
||||
cache: &Path,
|
||||
) -> IdeResult<Option<compile::BuildPlan>> {
|
||||
let (roots, jdk) = structure_inputs(root, settings, detected);
|
||||
compile::structure_plan(
|
||||
root,
|
||||
&settings.project_structure,
|
||||
&roots,
|
||||
jdk.as_ref(),
|
||||
&settings.languages.java.language_level,
|
||||
kind,
|
||||
cache,
|
||||
)
|
||||
let (ps, roots, jdk) = structure_inputs(root, settings, detected);
|
||||
compile::structure_plan(root, &ps, &roots, jdk.as_ref(), &settings.languages.java.language_level, kind, cache)
|
||||
}
|
||||
|
||||
/// The roots and JDK a build of a project without a build tool uses.
|
||||
/// The Project Structure, roots and JDK a build of a project without a build tool uses.
|
||||
/// An Eclipse project's `.classpath` libraries and its web content folder count as if they
|
||||
/// were configured, and a web project with no artifacts gets IDEA's `<name>:war exploded`.
|
||||
pub(crate) fn structure_inputs(
|
||||
root: &Path,
|
||||
settings: &Settings,
|
||||
detected: &[ide_workspace::roots::SourceFolder],
|
||||
) -> (compile::StructureRoots, Option<compile::StructureJdk>) {
|
||||
use ide_workspace::roots::{ProjectRoots, RootKind};
|
||||
let roots = ProjectRoots::compute(detected.to_vec(), &settings.project_structure);
|
||||
) -> (ide_core::settings::ProjectStructureSettings, compile::StructureRoots, Option<compile::StructureJdk>) {
|
||||
use ide_core::settings::{ArtifactConfig, ArtifactKind, FacetConfig, ProjectLibrary};
|
||||
use ide_workspace::roots::{ProjectRoots, RootKind, eclipse};
|
||||
let mut ps = settings.project_structure.clone();
|
||||
let mut included = Vec::new();
|
||||
if let Some(cp) = eclipse::classpath(root).filter(|cp| !cp.libraries.is_empty()) {
|
||||
let name = "Eclipse classpath".to_owned();
|
||||
if !ps.libraries.iter().any(|l| l.name == name) {
|
||||
ps.libraries.push(ProjectLibrary { name: name.clone(), classes: cp.libraries, ..Default::default() });
|
||||
}
|
||||
included.push(name);
|
||||
}
|
||||
if !ps.facets.iter().any(|f| f.kind == "web")
|
||||
&& let Some(web) = eclipse::web_root(root)
|
||||
{
|
||||
ps.facets.push(FacetConfig {
|
||||
kind: "web".into(),
|
||||
module: ".".into(),
|
||||
descriptor: format!("{web}/WEB-INF/web.xml"),
|
||||
web_root: web,
|
||||
});
|
||||
if ps.artifacts.is_empty() {
|
||||
let name = root.file_name().map_or_else(|| "app".into(), |n| n.to_string_lossy().into_owned());
|
||||
ps.artifacts.push(ArtifactConfig {
|
||||
name: format!("{name}:war exploded"),
|
||||
kind: ArtifactKind::WarExploded,
|
||||
module: ".".into(),
|
||||
include_libraries: included,
|
||||
..Default::default()
|
||||
});
|
||||
}
|
||||
}
|
||||
let roots = ProjectRoots::compute(detected.to_vec(), &ps);
|
||||
let of = |kind: RootKind| roots.roots.iter().filter(|r| r.kind == kind).map(|r| root.join(&r.path)).collect();
|
||||
let module = settings.project_structure.module_settings(root, root);
|
||||
let module = ps.module_settings(root, root);
|
||||
let level = module
|
||||
.map(|m| m.language_level.as_str())
|
||||
.filter(|l| !l.trim().is_empty())
|
||||
@@ -690,7 +714,7 @@ pub(crate) fn structure_inputs(
|
||||
test_resources: of(RootKind::TestResources),
|
||||
excluded: of(RootKind::Excluded),
|
||||
};
|
||||
(roots, jdk)
|
||||
(ps, roots, jdk)
|
||||
}
|
||||
|
||||
fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id: &str) -> IdeResult<compile::BuildPlan> {
|
||||
|
||||
@@ -12,6 +12,25 @@ use std::path::PathBuf;
|
||||
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
|
||||
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
|
||||
host.require_trust(window)?;
|
||||
let unity_pid = if config.adapter == "unity" {
|
||||
if config.request != "attach" {
|
||||
return Err(ide_core::IdeError::invalid("Unity debugging only supports attachment to a running Editor"));
|
||||
}
|
||||
let arguments = launch_arguments(&config)?;
|
||||
let pid = arguments["name"]
|
||||
.as_str()
|
||||
.and_then(|name| name.strip_prefix("Unity Editor ("))
|
||||
.and_then(|name| name.strip_suffix(')'))
|
||||
.and_then(|pid| pid.parse::<u32>().ok());
|
||||
if let Some(pid) = pid {
|
||||
require_unity_editor(pid)?;
|
||||
}
|
||||
let cwd = config.cwd.as_ref().map(|path| path.as_ref()).unwrap_or_else(|| std::path::Path::new("."));
|
||||
unity::require_runtime(cwd)?;
|
||||
pid
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
|
||||
if config.adapter == "debugpy"
|
||||
&& config.request == "launch"
|
||||
@@ -100,12 +119,26 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
let server_port = debug_server_port(&config);
|
||||
let result = host.debugger.start_with(config, owner, custom).await;
|
||||
flush_output();
|
||||
if result.is_err()
|
||||
&& let Some(pid) = unity_pid
|
||||
{
|
||||
require_unity_editor(pid)?;
|
||||
}
|
||||
if let (Ok(id), Some(port)) = (&result, server_port) {
|
||||
attach_jvm_inspector(host, window, *id, port);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn require_unity_editor(pid: u32) -> IdeResult<()> {
|
||||
if !ide_core::process::process_alive(pid) {
|
||||
return Err(ide_core::IdeError::unavailable(format!(
|
||||
"Unity Editor (PID {pid}) is no longer running. Refresh the Unity process list and select a running Editor."
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The port of the java-debug server this machine's jdtls started; `debugServer` as `host:port`
|
||||
/// names an adapter on another machine, whose jdtls is not ours to ask.
|
||||
fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
|
||||
@@ -460,6 +493,17 @@ pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
|
||||
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
|
||||
}
|
||||
|
||||
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
if ide_workspace::unity::detect(&project.root).is_none() {
|
||||
return Err(ide_core::IdeError::invalid("Open a Unity project before attaching to the Editor"));
|
||||
}
|
||||
let command = ide_sdk::apply::tool_command(&project.root, &project.settings.effective(), "unity-debug")
|
||||
.map(|p| p.to_string_lossy().into_owned());
|
||||
unity::editors(command, project.root.clone()).await
|
||||
}
|
||||
|
||||
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
|
||||
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
|
||||
pub async fn debug_listen_for_jvm(
|
||||
@@ -664,6 +708,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
});
|
||||
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
|
||||
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
|
||||
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
|
||||
d.add("debug_listen_for_jvm", |c| async move {
|
||||
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
|
||||
});
|
||||
|
||||
@@ -205,8 +205,8 @@ pub async fn run_tomcat_installations(
|
||||
/// Id prefix of a Project Structure WAR artifact (a project without a build tool).
|
||||
const PROJECT_ARTIFACT: &str = "project:";
|
||||
|
||||
fn project_web_artifacts(settings: &ide_core::settings::Settings) -> Vec<ide_build::web::WebArtifact> {
|
||||
ide_build::compile::structure_web_artifacts(&settings.project_structure)
|
||||
fn project_web_artifacts(ps: &ide_core::settings::ProjectStructureSettings) -> Vec<ide_build::web::WebArtifact> {
|
||||
ide_build::compile::structure_web_artifacts(ps)
|
||||
.into_iter()
|
||||
.map(|a| ide_build::web::WebArtifact {
|
||||
id: format!("{PROJECT_ARTIFACT}{}", a.name),
|
||||
@@ -228,20 +228,19 @@ fn build_project_war(
|
||||
cache: &std::path::Path,
|
||||
) -> IdeResult<()> {
|
||||
use ide_build::compile;
|
||||
let artifact = settings
|
||||
.project_structure
|
||||
let (ps, roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
|
||||
let artifact = ps
|
||||
.artifacts
|
||||
.iter()
|
||||
.find(|a| a.name == name)
|
||||
.ok_or_else(|| IdeError::invalid(format!("No artifact named {name} in Project Structure › Artifacts")))?;
|
||||
let (roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
|
||||
let war = base.join("artifact").join(format!(
|
||||
"{}.war",
|
||||
name.split(':').next().unwrap_or(name).replace(|c: char| !c.is_alphanumeric() && c != '-', "_")
|
||||
));
|
||||
let plan = compile::structure_war_plan(
|
||||
root,
|
||||
&settings.project_structure,
|
||||
&ps,
|
||||
&roots,
|
||||
jdk.as_ref(),
|
||||
&settings.languages.java.language_level,
|
||||
@@ -278,7 +277,9 @@ pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<id
|
||||
let mut artifacts = ide_build::web::artifacts(&project.root, &model);
|
||||
// Without a build tool, the Project Structure's WAR artifacts are built by the IDE.
|
||||
if model.maven.is_none() && model.gradle.is_empty() {
|
||||
artifacts.extend(project_web_artifacts(&settings));
|
||||
let detected = project.detected_roots.read().clone();
|
||||
let (ps, _, _) = crate::ops::build::structure_inputs(&project.root, &settings, &detected);
|
||||
artifacts.extend(project_web_artifacts(&ps));
|
||||
}
|
||||
artifacts
|
||||
})
|
||||
|
||||
@@ -338,6 +338,15 @@ pub fn env_wrapper(bin_dir: &Path, command: &str, target: &Path, env: &[(&str, &
|
||||
}
|
||||
|
||||
pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResult<PathBuf> {
|
||||
link_executable_with_runtime(bin_dir, command, target, None)
|
||||
}
|
||||
|
||||
pub fn link_executable_with_runtime(
|
||||
bin_dir: &Path,
|
||||
command: &str,
|
||||
target: &Path,
|
||||
runtime: Option<&str>,
|
||||
) -> IdeResult<PathBuf> {
|
||||
fs::create_dir_all(bin_dir)?;
|
||||
#[cfg(unix)]
|
||||
{
|
||||
@@ -347,7 +356,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
|
||||
}
|
||||
let quoted = target.to_string_lossy().replace('\'', r"'\''");
|
||||
// A Node script without a shebang (e.g. js-debug's dapDebugServer.js) runs through `node`.
|
||||
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
|
||||
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
|
||||
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
|
||||
fs::write(&link, format!("#!/bin/sh\nexec {runner}'{quoted}' \"$@\"\n"))?;
|
||||
make_executable(&link)?;
|
||||
make_executable(target)?;
|
||||
@@ -356,7 +366,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
|
||||
#[cfg(not(unix))]
|
||||
{
|
||||
let link = bin_dir.join(format!("{command}.cmd"));
|
||||
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
|
||||
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
|
||||
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
|
||||
fs::write(&link, format!("@echo off\r\n{runner}\"{}\" %*\r\n", cmd_path(bin_dir, target)))?;
|
||||
Ok(link)
|
||||
}
|
||||
@@ -510,6 +521,34 @@ mod tests {
|
||||
assert!(dest.join("ok.txt").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unity_vsix_wrapper_preserves_managed_assemblies_and_uses_mono_on_unix() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let archive = tmp.path().join("unity.vsix");
|
||||
zip_file(
|
||||
&archive,
|
||||
&[
|
||||
("extension/bin/UnityDebug.exe", b"adapter", 0o644),
|
||||
("extension/bin/UnityDebug.exe.config", b"runtime config", 0o644),
|
||||
("extension/bin/Mono.Debugger.Soft.dll", b"dependency", 0o644),
|
||||
],
|
||||
);
|
||||
let dest = tmp.path().join("install with spaces");
|
||||
extract(&archive, ArchiveKind::Zip, &dest, "unity-debug", &CancellationToken::new()).unwrap();
|
||||
let target = locate(&dest, &["UnityDebug.exe".into()]).unwrap();
|
||||
let wrapper =
|
||||
link_executable_with_runtime(&dest.join("bin"), "unity-debug", &target, cfg!(unix).then_some("mono"))
|
||||
.unwrap();
|
||||
let script = fs::read_to_string(wrapper).unwrap();
|
||||
assert!(script.contains(&*target.to_string_lossy()));
|
||||
#[cfg(unix)]
|
||||
assert!(script.contains("exec mono '") && script.contains("\"$@\""));
|
||||
#[cfg(windows)]
|
||||
assert!(script.contains("\" %*") && !script.contains("mono "));
|
||||
assert_eq!(fs::read(target.with_extension("exe.config")).unwrap(), b"runtime config");
|
||||
assert_eq!(fs::read(target.parent().unwrap().join("Mono.Debugger.Soft.dll")).unwrap(), b"dependency");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zip_symlinks_are_confined_to_the_destination() {
|
||||
for target in ["../outside", "/tmp/outside", "a/../../outside"] {
|
||||
|
||||
@@ -1296,6 +1296,14 @@ impl Tools {
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<sources::Download> {
|
||||
match source {
|
||||
ReleaseSource::Fixed { version, url, sha256 } => Ok(sources::Download {
|
||||
version: version.into(),
|
||||
name: url.rsplit('/').next().unwrap_or("download").into(),
|
||||
url: url.into(),
|
||||
size: None,
|
||||
sha256: Some(sha256.into()),
|
||||
checksum_url: None,
|
||||
}),
|
||||
ReleaseSource::GitHub { repo } => match http.get_text(&sources::github_latest_url(repo), cancel) {
|
||||
Ok(json) => sources::github_pick(&json, assets, self.platform),
|
||||
Err(e) if e.kind == ErrorKind::Cancelled => Err(e),
|
||||
@@ -1442,7 +1450,11 @@ impl Tools {
|
||||
} else {
|
||||
archive::make_executable(&target)?;
|
||||
if self.exe_in(&bin, main).as_deref() != Some(target.as_path()) {
|
||||
archive::link_executable(&bin, main, &target)?;
|
||||
if spec.name == "unity-debug" && cfg!(unix) {
|
||||
archive::link_executable_with_runtime(&bin, main, &target, Some("mono"))?;
|
||||
} else {
|
||||
archive::link_executable(&bin, main, &target)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
self.write_manifest(spec.name, &Manifest { version: Some(dl.version.clone()), source: Some(dl.url.clone()) })
|
||||
|
||||
@@ -20,6 +20,8 @@ pub enum ToolKind {
|
||||
/// Where release archives come from.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum ReleaseSource {
|
||||
/// One pinned archive, verified against its SHA-256 before extraction.
|
||||
Fixed { version: &'static str, url: &'static str, sha256: &'static str },
|
||||
/// Latest GitHub release of `owner/repo`; assets plus links in the release notes.
|
||||
GitHub { repo: &'static str },
|
||||
/// `api.releases.hashicorp.com` product.
|
||||
@@ -80,6 +82,7 @@ impl Method {
|
||||
Method::Release { source: ReleaseSource::EclipseJdtls, .. } => "Eclipse download",
|
||||
Method::Release { source: ReleaseSource::OpenVsx { .. }, .. } => "Open VSX",
|
||||
Method::Release { source: ReleaseSource::MavenCentral { .. }, .. } => "Maven Central",
|
||||
Method::Release { source: ReleaseSource::Fixed { .. }, .. } => "Verified download",
|
||||
Method::Release { .. } => "GitHub release",
|
||||
}
|
||||
}
|
||||
@@ -131,6 +134,29 @@ const fn ver(cmd: &'static str) -> Option<(&'static str, &'static [&'static str]
|
||||
pub const TYPESCRIPT: &str = "typescript@6";
|
||||
|
||||
pub static TOOLS: &[ToolSpec] = &[
|
||||
ToolSpec {
|
||||
name: "unity-debug",
|
||||
display: "Unity Debugger",
|
||||
kind: Debugger,
|
||||
commands: &["unity-debug"],
|
||||
method: Method::Release {
|
||||
source: ReleaseSource::Fixed {
|
||||
version: "3.0.1",
|
||||
url: "https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/Version-3.0.1/unity-debug-3.0.1.vsix",
|
||||
sha256: "4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0",
|
||||
},
|
||||
assets: &[any_arch(Mac, "*.vsix"), any_arch(Linux, "*.vsix"), any_arch(Windows, "*.vsix")],
|
||||
locate: &["UnityDebug.exe"],
|
||||
},
|
||||
fallback: None,
|
||||
version: V,
|
||||
homepage: "https://github.com/Unity-Technologies/vscode-unity-debug",
|
||||
needs: if cfg!(windows) {
|
||||
&[]
|
||||
} else {
|
||||
&[("mono", "Mono is required to run the Unity debugger (https://www.mono-project.com)")]
|
||||
},
|
||||
},
|
||||
ToolSpec {
|
||||
name: "prettier",
|
||||
display: "Prettier",
|
||||
@@ -1164,6 +1190,8 @@ mod tests {
|
||||
fn registry_names_match_language_configs() {
|
||||
let langs = ide_language::LanguageRegistry::load(None).unwrap().all();
|
||||
let mut known = std::collections::HashSet::new();
|
||||
// The Unity debugger comes with Unity projects, apart from the C# debugger.
|
||||
known.insert(("unity-debug".to_owned(), "unity-debug".to_owned()));
|
||||
for l in &langs {
|
||||
for s in &l.language_servers {
|
||||
known.insert((s.name.clone(), s.command.clone()));
|
||||
|
||||
@@ -49,6 +49,24 @@ fn find<'a>(list: &'a [ToolInfo], name: &str) -> &'a ToolInfo {
|
||||
list.iter().find(|t| t.name == name).unwrap_or_else(|| panic!("{name} not listed"))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unity_adapter_download_is_pinned_and_checksum_verified() {
|
||||
let env = Env::new();
|
||||
let tools = env.tools();
|
||||
let spec = registry::find("unity-debug").unwrap();
|
||||
let Method::Release { source, assets, locate } = spec.method else { panic!("expected release") };
|
||||
// A fixed release resolves without a network request.
|
||||
let curl = env.sys.join(if cfg!(windows) { "curl.exe" } else { "curl" });
|
||||
fs::write(&curl, b"unused").unwrap();
|
||||
archive::make_executable(&curl).unwrap();
|
||||
let http = Http::new(env.sys.as_os_str()).unwrap();
|
||||
let download = tools.resolve_release(&http, source, assets, &CancellationToken::new()).unwrap();
|
||||
assert_eq!(download.version, "3.0.1");
|
||||
assert!(download.url.starts_with("https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/"));
|
||||
assert_eq!(download.sha256.as_deref(), Some("4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0"));
|
||||
assert_eq!(locate, &["UnityDebug.exe"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bundled_lombok_replaces_legacy_installs_on_every_platform_without_downloads() {
|
||||
for os in [Os::Mac, Os::Linux, Os::Windows] {
|
||||
|
||||
@@ -33,6 +33,7 @@ pub(crate) fn virtual_env_marker(dir: &Path) -> Option<&'static str> {
|
||||
/// Build files whose changes can change the detected roots.
|
||||
pub(crate) const BUILD_FILES: &[&str] = &[
|
||||
"pom.xml",
|
||||
".classpath",
|
||||
"build.gradle",
|
||||
"build.gradle.kts",
|
||||
"settings.gradle",
|
||||
@@ -238,6 +239,20 @@ fn module_roots(root: &Path, rel: &str, files: &[String], out: &mut Vec<SourceFo
|
||||
}
|
||||
}
|
||||
|
||||
// An Eclipse project without Maven or Gradle: its `.classpath` is the source model.
|
||||
if has(".classpath")
|
||||
&& !has("pom.xml")
|
||||
&& !GRADLE_FILES.iter().any(|f| has(f))
|
||||
&& let Some(cp) = super::eclipse::classpath(&dir)
|
||||
{
|
||||
for (sub, test) in &cp.sources {
|
||||
add(sub, if *test { RootKind::Test } else { RootKind::Source }, ".classpath");
|
||||
}
|
||||
if let Some(output) = &cp.output {
|
||||
add(output, RootKind::Excluded, ".classpath");
|
||||
}
|
||||
}
|
||||
|
||||
// Before `package.json`: a Laravel app's `tests/` is the PHP test root.
|
||||
if has("composer.json")
|
||||
&& let Ok(text) = std::fs::read_to_string(dir.join("composer.json"))
|
||||
|
||||
@@ -0,0 +1,193 @@
|
||||
//! Eclipse projects without Maven or Gradle: `.classpath` names the source folders (tests
|
||||
//! by their `test` attribute), the output folder and the library jars; a Dynamic Web
|
||||
//! Project's `.settings/org.eclipse.wst.common.component` names the web content folder.
|
||||
use std::path::Path;
|
||||
|
||||
/// What `.classpath` declares, with project-relative `/`-separated paths.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq)]
|
||||
pub struct EclipseClasspath {
|
||||
/// Source folders and whether they hold tests.
|
||||
pub sources: Vec<(String, bool)>,
|
||||
pub output: Option<String>,
|
||||
/// Library jars or class folders (`kind="lib"`), project-relative or absolute.
|
||||
pub libraries: Vec<String>,
|
||||
}
|
||||
|
||||
/// The value of `name="…"` in a tag's text.
|
||||
fn attribute(tag: &str, name: &str) -> Option<String> {
|
||||
let mut rest = tag;
|
||||
while let Some(at) = rest.find(name) {
|
||||
let before = rest[..at].chars().last();
|
||||
let after = &rest[at + name.len()..];
|
||||
rest = after;
|
||||
if before.is_some_and(|c| !c.is_whitespace()) {
|
||||
continue;
|
||||
}
|
||||
let Some(after) = after.trim_start().strip_prefix('=') else { continue };
|
||||
let after = after.trim_start();
|
||||
let quote = after.chars().next().filter(|c| *c == '"' || *c == '\'')?;
|
||||
let value = &after[1..];
|
||||
let end = value.find(quote)?;
|
||||
return Some(unescape(&value[..end]));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn unescape(value: &str) -> String {
|
||||
value.replace(""", "\"").replace("'", "'").replace("<", "<").replace(">", ">").replace("&", "&")
|
||||
}
|
||||
|
||||
/// Each element `<name …>…</name>` or `<name …/>` as (opening tag, inner text).
|
||||
fn elements<'a>(text: &'a str, name: &str) -> Vec<(&'a str, &'a str)> {
|
||||
let open = format!("<{name}");
|
||||
let close = format!("</{name}>");
|
||||
let mut out = Vec::new();
|
||||
let mut rest = text;
|
||||
while let Some(at) = rest.find(&open) {
|
||||
let from = &rest[at..];
|
||||
// `<classpathentry` must not match `<classpathentryX`.
|
||||
if !from[open.len()..].starts_with(|c: char| c.is_whitespace() || c == '/' || c == '>') {
|
||||
rest = &from[open.len()..];
|
||||
continue;
|
||||
}
|
||||
let Some(end) = from.find('>') else { break };
|
||||
let tag = &from[..=end];
|
||||
if tag.ends_with("/>") {
|
||||
out.push((tag, ""));
|
||||
rest = &from[end + 1..];
|
||||
} else {
|
||||
let body = &from[end + 1..];
|
||||
let stop = body.find(&close).unwrap_or(body.len());
|
||||
out.push((tag, &body[..stop]));
|
||||
rest = &body[stop..];
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn clean(path: &str) -> String {
|
||||
let p = path.trim().replace('\\', "/");
|
||||
let p = p.trim_start_matches("./").trim_end_matches('/');
|
||||
p.to_owned()
|
||||
}
|
||||
|
||||
pub fn parse_classpath(text: &str) -> EclipseClasspath {
|
||||
let mut out = EclipseClasspath::default();
|
||||
for (tag, body) in elements(text, "classpathentry") {
|
||||
let (Some(kind), Some(path)) = (attribute(tag, "kind"), attribute(tag, "path")) else { continue };
|
||||
let path = clean(&path);
|
||||
match kind.as_str() {
|
||||
// `/OtherProject` is a project reference, not a folder of this one.
|
||||
"src" if !path.starts_with('/') && !path.is_empty() => {
|
||||
let test = elements(body, "attribute").iter().any(|(a, _)| {
|
||||
attribute(a, "name").as_deref() == Some("test") && attribute(a, "value").as_deref() == Some("true")
|
||||
});
|
||||
out.sources.push((path, test));
|
||||
}
|
||||
"output" if !path.is_empty() => out.output = Some(path),
|
||||
"lib" if !path.is_empty() => out.libraries.push(path),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The project's `.classpath`, unless a Maven or Gradle build owns its model.
|
||||
pub fn classpath(dir: &Path) -> Option<EclipseClasspath> {
|
||||
if ["pom.xml", "build.gradle", "build.gradle.kts"].iter().any(|f| dir.join(f).is_file()) {
|
||||
return None;
|
||||
}
|
||||
std::fs::read_to_string(dir.join(".classpath")).ok().map(|t| parse_classpath(&t))
|
||||
}
|
||||
|
||||
/// The web content folder of a web project: the `wb-resource` deployed at `/`, else a
|
||||
/// conventional `WebContent` / `WebRoot` / `web` / `src/main/webapp` holding `WEB-INF/web.xml`.
|
||||
pub fn web_root(dir: &Path) -> Option<String> {
|
||||
if let Ok(text) = std::fs::read_to_string(dir.join(".settings/org.eclipse.wst.common.component")) {
|
||||
for (tag, _) in elements(&text, "wb-resource") {
|
||||
if attribute(tag, "deploy-path").as_deref() == Some("/")
|
||||
&& let Some(source) = attribute(tag, "source-path")
|
||||
{
|
||||
let source = clean(source.trim_start_matches('/'));
|
||||
if dir.join(&source).is_dir() {
|
||||
return Some(source);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
["WebContent", "WebRoot", "web", "src/main/webapp"]
|
||||
.into_iter()
|
||||
.find(|d| dir.join(d).join("WEB-INF/web.xml").is_file())
|
||||
.map(str::to_owned)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn reads_sources_tests_output_and_libraries() {
|
||||
let cp = parse_classpath(
|
||||
r#"<?xml version="1.0" encoding="UTF-8"?>
|
||||
<classpath>
|
||||
<classpathentry kind="src" path="src"/>
|
||||
<classpathentry kind="src" output="bin/test" path="test">
|
||||
<attributes>
|
||||
<attribute name="test" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry kind="src" path="/OtherProject"/>
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
|
||||
<classpathentry kind="lib" path="WebContent/WEB-INF/lib/commons-lang.jar"/>
|
||||
<classpathentry kind='lib' path='lib\mail.jar' sourcepath="lib/mail-src.zip"/>
|
||||
<classpathentry kind="output" path="build/classes"/>
|
||||
</classpath>"#,
|
||||
);
|
||||
assert_eq!(cp.sources, [("src".to_owned(), false), ("test".to_owned(), true)]);
|
||||
assert_eq!(cp.output.as_deref(), Some("build/classes"));
|
||||
assert_eq!(cp.libraries, ["WebContent/WEB-INF/lib/commons-lang.jar", "lib/mail.jar"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn finds_the_web_content_folder() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
std::fs::create_dir_all(dir.path().join("site/WEB-INF")).unwrap();
|
||||
std::fs::create_dir_all(dir.path().join(".settings")).unwrap();
|
||||
std::fs::write(
|
||||
dir.path().join(".settings/org.eclipse.wst.common.component"),
|
||||
r#"<project-modules><wb-module deploy-name="shop">
|
||||
<wb-resource deploy-path="/WEB-INF/classes" source-path="/src"/>
|
||||
<wb-resource deploy-path="/" source-path="/site" tag="defaultRootSource"/>
|
||||
</wb-module></project-modules>"#,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(web_root(dir.path()).as_deref(), Some("site"));
|
||||
let plain = tempfile::tempdir().unwrap();
|
||||
std::fs::create_dir_all(plain.path().join("WebRoot/WEB-INF")).unwrap();
|
||||
assert_eq!(web_root(plain.path()), None);
|
||||
std::fs::write(plain.path().join("WebRoot/WEB-INF/web.xml"), "<web-app/>").unwrap();
|
||||
assert_eq!(web_root(plain.path()).as_deref(), Some("WebRoot"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn detects_the_roots_of_an_eclipse_project() {
|
||||
use super::super::{RootKind, detect};
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
for d in ["src", "test", "bin"] {
|
||||
std::fs::create_dir_all(dir.path().join(d)).unwrap();
|
||||
}
|
||||
std::fs::write(
|
||||
dir.path().join(".classpath"),
|
||||
r#"<classpath><classpathentry kind="src" path="src"/><classpathentry kind="src" path="test"><attributes><attribute name="test" value="true"/></attributes></classpathentry><classpathentry kind="output" path="bin"/></classpath>"#,
|
||||
)
|
||||
.unwrap();
|
||||
let roots: Vec<(String, RootKind)> = detect(dir.path()).into_iter().map(|r| (r.path, r.kind)).collect();
|
||||
assert_eq!(
|
||||
roots,
|
||||
[("bin".into(), RootKind::Excluded), ("src".into(), RootKind::Source), ("test".into(), RootKind::Test)]
|
||||
);
|
||||
// A Maven build owns the model even with a stale `.classpath` next to it.
|
||||
std::fs::write(dir.path().join("pom.xml"), "<project/>").unwrap();
|
||||
assert!(detect(dir.path()).iter().all(|r| r.detected_from.as_deref() != Some(".classpath")));
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@
|
||||
//! project-relative and `/`-separated; `""` is the project root itself.
|
||||
|
||||
mod detect;
|
||||
pub mod eclipse;
|
||||
pub(crate) use detect::{BUILD_FILES, virtual_env_marker};
|
||||
mod gradle;
|
||||
mod java;
|
||||
|
||||
@@ -30,12 +30,14 @@ pub enum SettingsScope {
|
||||
/// Settings a project's own file can't hold: the IDE's MCP server, imported color schemes, and
|
||||
/// what agents may do without asking (commands run without asking, the modes new tasks start in,
|
||||
/// whether new tasks ask for approvals).
|
||||
const USER_ONLY: [&[&str]; 5] = [
|
||||
const USER_ONLY: [&[&str]; 6] = [
|
||||
&["mcpServer"],
|
||||
&["editor", "customSchemes"],
|
||||
&["agentSecurity", "allowedCommands"],
|
||||
&["agents", "defaults"],
|
||||
&["agents", "newTaskApprovals"],
|
||||
// OS notification centre: machine-local; projects must not enable/disable.
|
||||
&["notifications", "systemNotifications"],
|
||||
];
|
||||
|
||||
/// The [`USER_ONLY`] setting that writing `value` at `key` would set, as a dotted key.
|
||||
@@ -1219,4 +1221,22 @@ mod tests {
|
||||
std::fs::write(project.join(".openidea/settings.toml"), "[agents]\nnewTaskApprovals = \"bypass\"\n").unwrap();
|
||||
assert_eq!(settings.reload().agents.new_task_approvals, NewTaskApprovals::Ask);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn system_notifications_are_a_user_setting() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let config = tmp.path().join("config");
|
||||
let project = tmp.path().join("project");
|
||||
std::fs::create_dir_all(project.join(".openidea")).unwrap();
|
||||
std::fs::write(project.join(".openidea/settings.toml"), "[notifications]\nsystemNotifications = false\n")
|
||||
.unwrap();
|
||||
let settings = SettingsStore::load(&config, Some(&project));
|
||||
assert!(settings.effective().notifications.system_notifications);
|
||||
assert!(settings.set(SettingsScope::Project, "notifications.systemNotifications", json!(false)).is_err());
|
||||
let s = settings.set(SettingsScope::Global, "notifications.systemNotifications", json!(false)).unwrap();
|
||||
assert!(!s.notifications.system_notifications);
|
||||
std::fs::write(project.join(".openidea/settings.toml"), "[notifications]\nsystemNotifications = true\n")
|
||||
.unwrap();
|
||||
assert!(!settings.reload().notifications.system_notifications);
|
||||
}
|
||||
}
|
||||
@@ -152,12 +152,13 @@ Sub-tables such as `[editor.general]`, `[editor.appearance]`, `[editor.completio
|
||||
|
||||
### `[notifications]`
|
||||
|
||||
| Key | Default | Description |
|
||||
| --------------------------- | ----------- | ------------------------------------------------------------ |
|
||||
| `balloons` | `true` | **Display balloon notifications**. |
|
||||
| `sound` | `false` | **Play sound**. |
|
||||
| `groups.<group-id>.display` | `"balloon"` | Popup type per group: `balloon`, `sticky` or `none`. |
|
||||
| `groups.<group-id>.log` | `true` | Also list the notification in the Notifications tool window. |
|
||||
| Key | Default | Description |
|
||||
| --------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| `balloons` | `true` | **Display balloon notifications**. |
|
||||
| `sound` | `false` | **Play sound**. |
|
||||
| `systemNotifications` | `true` | **Enable system notifications**. When a balloon is shown and no OpenIDEA window is focused, the same title and text also go to the OS notification centre. On by default; client/local only. Click focuses the window that raised the toast; balloon actions stay in the IDE. **Windows:** a click is reported only while the toast is on screen, not after it moves to Action Center. Desktop `permission_state` always reports Granted without an OS prompt — that is not proof Do Not Disturb or system notification settings allow delivery. |
|
||||
| `groups.<group-id>.display` | `"balloon"` | Popup type per group: `balloon`, `sticky` or `none`. |
|
||||
| `groups.<group-id>.log` | `true` | Also list the notification in the Notifications tool window. |
|
||||
|
||||
### `[terminal]`
|
||||
|
||||
|
||||
@@ -152,12 +152,13 @@ exclude = ["**/.git", "**/node_modules", "**/target", "**/dist"]
|
||||
|
||||
### `[notifications]`
|
||||
|
||||
| 键 | 默认值 | 说明 |
|
||||
| --------------------------- | ----------- | --------------------------------------------------- |
|
||||
| `balloons` | `true` | **显示气球通知**。 |
|
||||
| `sound` | `false` | **播放声音**。 |
|
||||
| `groups.<group-id>.display` | `"balloon"` | 每个分组的弹出方式:`balloon`、`sticky` 或 `none`。 |
|
||||
| `groups.<group-id>.log` | `true` | 同时在通知工具窗口中列出。 |
|
||||
| 键 | 默认值 | 说明 |
|
||||
| --------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `balloons` | `true` | **显示气球通知**。 |
|
||||
| `sound` | `false` | **播放声音**。 |
|
||||
| `systemNotifications` | `true` | **启用系统通知**。气球通知显示且没有任何 OpenIDEA 窗口处于焦点时,相同的标题和正文也会发到操作系统通知中心。默认开启;仅客户端/本机设置。点击会聚焦发出该通知的窗口;气球操作仍只在 IDE 内。**Windows:**仅在 toast 仍显示在屏幕上时可收到点击,进入操作中心后不再触发。桌面端 `permission_state` 始终返回 Granted 且不会弹出系统授权——这并不表示勿扰模式或系统通知设置允许显示。 |
|
||||
| `groups.<group-id>.display` | `"balloon"` | 每个分组的弹出方式:`balloon`、`sticky` 或 `none`。 |
|
||||
| `groups.<group-id>.log` | `true` | 同时在通知工具窗口中列出。 |
|
||||
|
||||
### `[terminal]`
|
||||
|
||||
|
||||
@@ -16,6 +16,7 @@ dunce.workspace = true
|
||||
[dependencies]
|
||||
tauri = { version = "2", features = [] }
|
||||
tauri-plugin-opener = "2"
|
||||
tauri-plugin-notification = "2.8.1"
|
||||
tauri-plugin-dialog = { version = "2", default-features = false, features = ["xdg-portal"] }
|
||||
tauri-plugin-mcp-bridge = "0.13"
|
||||
tauri-plugin-window-state = "2"
|
||||
|
||||
@@ -16,6 +16,7 @@
|
||||
"core:webview:allow-set-webview-background-color",
|
||||
"opener:default",
|
||||
"opener:allow-reveal-item-in-dir",
|
||||
"notification:default",
|
||||
"dialog:default",
|
||||
"core:window:allow-destroy",
|
||||
"core:window:allow-close",
|
||||
|
||||
@@ -348,6 +348,15 @@ pub async fn debug_free_port(window: Window, state: State<'_, AppState>) -> IdeR
|
||||
ide_host::ops::debug::debug_free_port(&state.host, window.label()).await
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn debug_unity_processes(
|
||||
window: tauri::Window,
|
||||
state: State<'_, AppState>,
|
||||
) -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
ide_host::ops::debug::debug_unity_processes(&state.host, window.label()).await
|
||||
}
|
||||
|
||||
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
|
||||
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
|
||||
#[tauri::command]
|
||||
|
||||
@@ -35,6 +35,7 @@ pub mod lsp;
|
||||
pub mod mcp;
|
||||
pub mod nav;
|
||||
pub mod notebook;
|
||||
pub mod notification;
|
||||
pub mod perf;
|
||||
pub mod plugin;
|
||||
pub mod profiler;
|
||||
@@ -199,6 +200,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
|
||||
clipboard::clipboard_has_image,
|
||||
clipboard::clipboard_image,
|
||||
clipboard::clipboard_set_file_list,
|
||||
notification::show_system_notification,
|
||||
fonts::system_font_families,
|
||||
doc::doc_open,
|
||||
doc::doc_open_virtual,
|
||||
@@ -551,6 +553,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
|
||||
debug::debug_data_breakpoint_info,
|
||||
debug::debug_attachable_processes,
|
||||
debug::debug_free_port,
|
||||
debug::debug_unity_processes,
|
||||
debug::debug_listen_for_jvm,
|
||||
debug::debug_redefine_classes,
|
||||
debug::debug_jvm_memory_classes,
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
//! IPC for OS notification centre toasts.
|
||||
|
||||
use ide_core::IdeResult;
|
||||
use tauri::{AppHandle, Window};
|
||||
|
||||
/// When a balloon is shown and OpenIDEA is unfocused, mirror it to the OS.
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn show_system_notification(app: AppHandle, window: Window, title: String, body: String) -> IdeResult<()> {
|
||||
crate::system_notifications::show(&app, window.label(), title, body);
|
||||
Ok(())
|
||||
}
|
||||
@@ -26,6 +26,7 @@ mod relaunch;
|
||||
mod remote_container;
|
||||
mod remote_dev;
|
||||
mod remote_wsl;
|
||||
mod system_notifications;
|
||||
|
||||
mod state;
|
||||
mod theme_frame;
|
||||
@@ -121,7 +122,10 @@ pub fn run() {
|
||||
// Install before window-state restores maximized geometry during window creation.
|
||||
#[cfg(windows)]
|
||||
let app = app.plugin(window_work_area::init());
|
||||
let app = app.plugin(tauri_plugin_opener::init()).plugin(tauri_plugin_dialog::init());
|
||||
let app = app
|
||||
.plugin(tauri_plugin_opener::init())
|
||||
.plugin(tauri_plugin_notification::init())
|
||||
.plugin(tauri_plugin_dialog::init());
|
||||
#[cfg(target_os = "linux")]
|
||||
let app = app.plugin(linux_window_state::plugin());
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
@@ -220,6 +224,7 @@ pub fn run() {
|
||||
windows::report_cli_error(app.handle(), error);
|
||||
}
|
||||
app.manage(application_focus::ApplicationFocus::default());
|
||||
system_notifications::init(app.handle());
|
||||
#[cfg(target_os = "macos")]
|
||||
macos::intercept_system_quit(app.handle());
|
||||
#[cfg(target_os = "macos")]
|
||||
|
||||
@@ -179,6 +179,7 @@ impl AppState {
|
||||
/// Called on the event-loop thread (window destruction, the `close_project`
|
||||
/// command), so it must not wait for the project's workers to shut down.
|
||||
pub fn close_project(&self, window: &str) {
|
||||
crate::system_notifications::clear_window(window);
|
||||
self.remote_dev.disconnect(window);
|
||||
self.host.close_project_detached(window);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
//! OS notification centre toasts for in-IDE balloons while OpenIDEA is unfocused.
|
||||
//!
|
||||
//! Driven by `show_system_notification` from the notification store. Honour
|
||||
//! global `[notifications].systemNotifications`; suppressed while any window is
|
||||
//! active. Click focuses the window that raised the toast — balloon actions stay
|
||||
//! in the IDE.
|
||||
|
||||
use parking_lot::Mutex;
|
||||
use std::collections::HashMap;
|
||||
use std::sync::LazyLock;
|
||||
use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
|
||||
use tauri::{AppHandle, Manager};
|
||||
use tauri_plugin_notification::{NotificationExt, PermissionState};
|
||||
|
||||
const MAX_TARGETS: usize = 64;
|
||||
|
||||
struct State {
|
||||
ready: AtomicBool,
|
||||
next_id: AtomicI32,
|
||||
/// Native notification id → owning window label.
|
||||
targets: Mutex<HashMap<i32, String>>,
|
||||
}
|
||||
|
||||
impl State {
|
||||
fn new() -> Self {
|
||||
Self { ready: AtomicBool::new(false), next_id: AtomicI32::new(1), targets: Mutex::new(HashMap::new()) }
|
||||
}
|
||||
|
||||
fn put_target(&self, id: i32, window: String) {
|
||||
let mut targets = self.targets.lock();
|
||||
targets.insert(id, window);
|
||||
while targets.len() > MAX_TARGETS {
|
||||
let oldest = targets.keys().copied().min();
|
||||
if let Some(oldest) = oldest {
|
||||
targets.remove(&oldest);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn take_target(&self, id: i32) -> Option<String> {
|
||||
self.targets.lock().remove(&id)
|
||||
}
|
||||
|
||||
fn clear_window(&self, window: &str) {
|
||||
self.targets.lock().retain(|_, w| w != window);
|
||||
}
|
||||
}
|
||||
|
||||
static STATE: LazyLock<State> = LazyLock::new(State::new);
|
||||
|
||||
/// Registers the notification plugin's activation handler once.
|
||||
pub fn init(app: &AppHandle) {
|
||||
if STATE.ready.swap(true, Ordering::AcqRel) {
|
||||
return;
|
||||
}
|
||||
let handle = app.clone();
|
||||
if let Err(e) = app.notification().on_action(move |performed| {
|
||||
if performed.action_id() != "tap" {
|
||||
return;
|
||||
}
|
||||
let Some(n) = performed.notification() else { return };
|
||||
activate(&handle, n.id());
|
||||
}) {
|
||||
tracing::warn!("system notifications: cannot register action handler: {e}");
|
||||
STATE.ready.store(false, Ordering::Release);
|
||||
}
|
||||
}
|
||||
|
||||
/// Project closed or window replaced: drop click targets for that owner.
|
||||
pub fn clear_window(window: &str) {
|
||||
STATE.clear_window(window);
|
||||
}
|
||||
|
||||
/// Show an OS toast when the setting is on and no OpenIDEA window is focused.
|
||||
pub fn show(app: &AppHandle, window: &str, title: String, body: String) {
|
||||
let owner = crate::state::AppState::owner_window(window).to_owned();
|
||||
let app = app.clone();
|
||||
let _ = app.clone().run_on_main_thread(move || deliver(&app, &owner, &title, &body));
|
||||
}
|
||||
|
||||
fn deliver(app: &AppHandle, window: &str, title: &str, body: &str) {
|
||||
let Some(state) = app.try_state::<crate::state::AppState>() else { return };
|
||||
let settings = state.host.global_settings.effective();
|
||||
if !settings.notifications.system_notifications {
|
||||
return;
|
||||
}
|
||||
if crate::application_focus::application_active(app) {
|
||||
return;
|
||||
}
|
||||
init(app);
|
||||
if !STATE.ready.load(Ordering::Acquire) {
|
||||
return;
|
||||
}
|
||||
// Desktop always reports Granted without an OS prompt (not proof of visible delivery).
|
||||
let granted = app
|
||||
.notification()
|
||||
.permission_state()
|
||||
.ok()
|
||||
.or_else(|| app.notification().request_permission().ok())
|
||||
.is_some_and(|s| s == PermissionState::Granted);
|
||||
if !granted {
|
||||
return;
|
||||
}
|
||||
|
||||
let id = STATE.next_id.fetch_add(1, Ordering::Relaxed);
|
||||
STATE.put_target(id, window.to_owned());
|
||||
|
||||
let mut builder = app.notification().builder().id(id).title(title).body(body);
|
||||
if settings.notifications.sound {
|
||||
builder = builder.sound("default");
|
||||
}
|
||||
if let Err(e) = builder.show() {
|
||||
tracing::debug!("system notification not shown: {e}");
|
||||
STATE.take_target(id);
|
||||
}
|
||||
}
|
||||
|
||||
fn activate(app: &AppHandle, id: i32) {
|
||||
let Some(window_label) = STATE.take_target(id) else { return };
|
||||
let app = app.clone();
|
||||
let _ = app.clone().run_on_main_thread(move || {
|
||||
let Some(window) = app.get_webview_window(&window_label) else { return };
|
||||
let _ = window.unminimize();
|
||||
let _ = window.show();
|
||||
let _ = window.set_focus();
|
||||
});
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::settings::NotificationSettings;
|
||||
|
||||
#[test]
|
||||
fn settings_default_on() {
|
||||
assert!(NotificationSettings::default().system_notifications);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clear_window_drops_targets() {
|
||||
let state = State::new();
|
||||
state.put_target(1, "w1".into());
|
||||
state.put_target(2, "w2".into());
|
||||
state.clear_window("w1");
|
||||
assert!(state.take_target(1).is_none());
|
||||
assert_eq!(state.take_target(2).as_deref(), Some("w2"));
|
||||
}
|
||||
}
|
||||
@@ -165,6 +165,7 @@ debug_step_in_target trusted project_host bin
|
||||
debug_step_in_targets trusted project_host bindings async
|
||||
debug_stop always project_host bindings async
|
||||
debug_threads trusted project_host bindings async
|
||||
debug_unity_processes trusted project_host bindings async
|
||||
debug_variables trusted project_host bindings async
|
||||
dependency_versions trusted project_host bindings async
|
||||
deploy_compare trusted project_host bindings async
|
||||
@@ -535,6 +536,7 @@ settings_list_jetbrains_ides always desktop bin
|
||||
settings_read_jetbrains always desktop bindings async
|
||||
settings_removed_theme always project_host bindings sync
|
||||
settings_set always project_host bindings sync
|
||||
show_system_notification trusted desktop bindings sync
|
||||
spell_check always project_host bindings async
|
||||
spell_suggest always project_host bindings async
|
||||
spring_route_sources trusted desktop bindings sync
|
||||
|
||||
+40
-2
@@ -331,6 +331,8 @@ export const commands = {
|
||||
* false when the clipboard stayed busy; the caller keeps working either way.
|
||||
*/
|
||||
clipboardSetFileList: (paths: string[]) => typedError<boolean, IdeError>(__TAURI_INVOKE("clipboard_set_file_list", { paths })),
|
||||
/** When a balloon is shown and OpenIDEA is unfocused, mirror it to the OS. */
|
||||
showSystemNotification: (title: string, body: string) => typedError<null, IdeError>(__TAURI_INVOKE("show_system_notification", { title, body })),
|
||||
/**
|
||||
* Every installed family, sorted, each flagged monospaced or not. Read on
|
||||
* first use (off the command threads), cached, and re-queried on `refresh`.
|
||||
@@ -1335,6 +1337,7 @@ export const commands = {
|
||||
debugAttachableProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_attachable_processes")),
|
||||
/** A loopback port that is free right now, for a debug agent the launch line starts. */
|
||||
debugFreePort: () => typedError<number, IdeError>(__TAURI_INVOKE("debug_free_port")),
|
||||
debugUnityProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_unity_processes")),
|
||||
/**
|
||||
* Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
|
||||
* JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
|
||||
@@ -1892,6 +1895,9 @@ export type AgentAcceptSkipped = {
|
||||
reason: string,
|
||||
};
|
||||
|
||||
/** Why a task needs the user's attention (native / in-app notify). */
|
||||
export type AgentAttentionReason = "finished" | "input" | "failed";
|
||||
|
||||
/** A task the agent runs in the background while the conversation goes on. */
|
||||
export type AgentBackgroundTask = {
|
||||
id: string,
|
||||
@@ -2098,7 +2104,9 @@ export type AgentEvent =
|
||||
/** A model lookup started or completed, including unsuccessful lookups. */
|
||||
{ type: "modelCatalog"; catalog: AgentModelCatalog } |
|
||||
/** The installed or configured agent providers changed. */
|
||||
{ type: "providers" };
|
||||
{ type: "providers" } |
|
||||
/** The task needs attention once (finished turn, explicit input, or failure). */
|
||||
{ type: "attention"; task: string; eventId: string; reason: AgentAttentionReason };
|
||||
|
||||
/** A form the agent asks the user to fill in (ACP `elicitation/create`, form mode). */
|
||||
export type AgentForm = {
|
||||
@@ -2730,7 +2738,7 @@ export type AskpassKind =
|
||||
/** Yes / no (an unknown host key); answered with `yes` or `no`. */
|
||||
"confirm";
|
||||
|
||||
export type AttachKind = "java" | "node" | "python" | "dotnet" | "go" | "native";
|
||||
export type AttachKind = "unity" | "java" | "node" | "python" | "dotnet" | "go" | "native";
|
||||
|
||||
export type AttachableProcess = {
|
||||
pid: number,
|
||||
@@ -3854,6 +3862,20 @@ export type DataSource_Serialize = {
|
||||
pluginSourceId?: string | null,
|
||||
};
|
||||
|
||||
/** Database settings: Query Execution and SQL Resolution Scopes. */
|
||||
export type DatabaseSettings = {
|
||||
/**
|
||||
* A console's result sets show under the statements that produced them, in the editor,
|
||||
* instead of in the Services view's result tabs.
|
||||
*/
|
||||
inEditorResults?: boolean,
|
||||
/**
|
||||
* Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
|
||||
* resolves against (completion, inspections, navigation), most specific path first.
|
||||
*/
|
||||
resolutionScopes?: SqlResolutionScope[],
|
||||
};
|
||||
|
||||
/** System Settings › Date Formats (Git log, Local History, blame). */
|
||||
export type DateFormatSettings = {
|
||||
/** Use `pattern` / `use24_hour` instead of the system locale's format. */
|
||||
@@ -7957,6 +7979,8 @@ export type NotificationLevel = "info" | "warning" | "error";
|
||||
export type NotificationSettings = {
|
||||
balloons?: boolean,
|
||||
sound?: boolean,
|
||||
/** Mirror balloon notifications to the OS when no OpenIDEA window is focused. */
|
||||
systemNotifications?: boolean,
|
||||
/** Group id → display; groups not listed use their default. */
|
||||
groups?: { [key in string]: NotificationGroupSettings },
|
||||
};
|
||||
@@ -9928,6 +9952,8 @@ export type Settings_Deserialize = {
|
||||
scopes?: NamedScope[],
|
||||
/** Appearance & Behavior › File Colors. */
|
||||
fileColors?: FileColorSettings,
|
||||
/** Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes. */
|
||||
database?: DatabaseSettings,
|
||||
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
|
||||
plugins?: { [key in string]: { [key in string]: unknown } },
|
||||
};
|
||||
@@ -9998,6 +10024,8 @@ export type Settings_Serialize = {
|
||||
scopes: NamedScope[],
|
||||
/** Appearance & Behavior › File Colors. */
|
||||
fileColors: FileColorSettings,
|
||||
/** Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes. */
|
||||
database: DatabaseSettings,
|
||||
/** Plugin settings (`[contributes.settings]`): plugin id → its values by key. */
|
||||
plugins: { [key in string]: { [key in string]: unknown } },
|
||||
};
|
||||
@@ -10146,6 +10174,16 @@ export type SpellingSettings = {
|
||||
customDictionaries?: string[],
|
||||
};
|
||||
|
||||
/** One row of SQL Resolution Scopes. */
|
||||
export type SqlResolutionScope = {
|
||||
/** Project-relative file or folder, `/`-separated; empty for the whole project. */
|
||||
path?: string,
|
||||
/** Data source id. */
|
||||
dataSource?: string,
|
||||
/** Schema unqualified names resolve in; empty for the data source's default. */
|
||||
schema?: string,
|
||||
};
|
||||
|
||||
export type SqlStatement = {
|
||||
/**
|
||||
* UTF-16 offsets of the statement text (whitespace trimmed, `;` excluded except
|
||||
|
||||
@@ -35,7 +35,6 @@ import {
|
||||
import {
|
||||
age,
|
||||
appendEntry,
|
||||
attentionChange,
|
||||
branchLabel,
|
||||
entriesKey,
|
||||
findSubagent,
|
||||
@@ -447,16 +446,6 @@ describe("agents model", () => {
|
||||
expect(appendEntry([u, a], 2, 0, "x")).toBeNull();
|
||||
});
|
||||
|
||||
it("notifies on finish, failure and questions only", () => {
|
||||
expect(attentionChange("running", "ready")).toBe("finished");
|
||||
expect(attentionChange("running", "failed")).toBe("failed");
|
||||
expect(attentionChange("running", "limited")).toBe("failed");
|
||||
expect(attentionChange("running", "needsInput")).toBe("input");
|
||||
expect(attentionChange("needsInput", "running")).toBeNull();
|
||||
expect(attentionChange("ready", "archived")).toBeNull();
|
||||
expect(attentionChange(undefined, "ready")).toBeNull();
|
||||
});
|
||||
|
||||
it("finds subagent cards and keys their conversations apart", () => {
|
||||
const card: SubagentEntry = {
|
||||
type: "subagent",
|
||||
|
||||
@@ -242,16 +242,3 @@ export function age(ms: number, now = Date.now()): string {
|
||||
if (h < 24) return `${h}h`;
|
||||
return `${Math.round(h / 24)}d`;
|
||||
}
|
||||
|
||||
/** The status change worth a notification, if any. */
|
||||
export function attentionChange(
|
||||
prev: AgentStatus | undefined,
|
||||
next: AgentStatus,
|
||||
): "finished" | "failed" | "input" | null {
|
||||
if (prev === next || prev === undefined) return null;
|
||||
if (next === "needsInput") return "input";
|
||||
if (!isBusy(prev)) return null;
|
||||
if (next === "ready") return "finished";
|
||||
if (next === "failed" || next === "limited") return "failed";
|
||||
return null;
|
||||
}
|
||||
@@ -53,7 +53,6 @@ import {
|
||||
SESSION_KIND,
|
||||
TOOL_WINDOW,
|
||||
appendEntry,
|
||||
attentionChange,
|
||||
entriesKey,
|
||||
isBusy,
|
||||
sessionKey,
|
||||
@@ -553,14 +552,17 @@ function onEvent(e: AgentEvent) {
|
||||
useAgents.setState({ tasks: new Map(s.tasks).set(e.task.id, e.task) });
|
||||
if (prev && (prev.title !== e.task.title || prev.status !== e.task.status)) notifyTabTitlesChanged();
|
||||
if (e.task.status === "archived") setUnread(e.task.id, false);
|
||||
else if (attentionChange(prev?.status, e.task.status)) markUnread(e.task.id);
|
||||
notifyChange(prev, e.task);
|
||||
if (prev?.status !== e.task.status && !isBusy(e.task.status)) {
|
||||
void refreshChanges(e.task.id);
|
||||
void refreshProviders();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "attention": {
|
||||
markUnread(e.task);
|
||||
notifyAttention(e.task, e.reason);
|
||||
break;
|
||||
}
|
||||
case "removed": {
|
||||
const tasks = new Map(s.tasks);
|
||||
tasks.delete(e.id);
|
||||
@@ -633,27 +635,28 @@ function onEvent(e: AgentEvent) {
|
||||
}
|
||||
}
|
||||
|
||||
function notifyChange(prev: AgentTask | undefined, task: AgentTask) {
|
||||
const change = attentionChange(prev?.status, task.status);
|
||||
if (!change) return;
|
||||
if (viewing(task.id)) return;
|
||||
/** In-app balloon for an Attention event; OS delivery goes through the general balloon path. */
|
||||
function notifyAttention(taskId: string, reason: "finished" | "input" | "failed") {
|
||||
if (viewing(taskId)) return;
|
||||
const task = useAgents.getState().tasks.get(taskId);
|
||||
const title = task?.title ?? "Agent";
|
||||
const body =
|
||||
change === "input"
|
||||
reason === "input"
|
||||
? "Waiting for your answer"
|
||||
: change === "failed"
|
||||
? (task.error ?? "The agent stopped")
|
||||
: reason === "failed"
|
||||
? (task?.error ?? "The agent stopped")
|
||||
: "Finished";
|
||||
notifications().notify({
|
||||
level: change === "failed" ? "error" : "info",
|
||||
title: task.title,
|
||||
level: reason === "failed" ? "error" : "info",
|
||||
title,
|
||||
body,
|
||||
key: `agent:${task.id}`,
|
||||
key: `agent:${taskId}`,
|
||||
group: "tools",
|
||||
sticky: change !== "finished",
|
||||
sticky: reason !== "finished",
|
||||
actions: [
|
||||
{
|
||||
label: change === "finished" ? "Review" : "Open",
|
||||
run: () => openTask(task.id),
|
||||
label: reason === "finished" ? "Review" : "Open",
|
||||
run: () => openTask(taskId),
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
@@ -163,16 +163,28 @@ describe("agent unread activity", () => {
|
||||
expect([...useAgents.getState().unread]).toEqual(["one"]);
|
||||
});
|
||||
|
||||
it.each(["ready", "needsInput", "failed", "limited"] as const)("marks background %s transitions unread", (status) => {
|
||||
it.each([
|
||||
["finished", "ready"],
|
||||
["input", "needsInput"],
|
||||
["failed", "failed"],
|
||||
["failed", "limited"],
|
||||
] as const)("marks background attention %s unread", (reason, status) => {
|
||||
emit({ type: "task", task: task("one", status) });
|
||||
emit({ type: "attention", task: "one", eventId: `one:${reason}:1`, reason });
|
||||
expect(useAgents.getState().unread.has("one")).toBe(true);
|
||||
expect(backend.notify).toHaveBeenCalledTimes(1);
|
||||
show();
|
||||
emit({ type: "task", task: task("one", status) });
|
||||
emit({ type: "attention", task: "one", eventId: `one:${reason}:2`, reason });
|
||||
expect(useAgents.getState().unread.size).toBe(0);
|
||||
expect(backend.notify).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it("does not notify from status alone once Attention exists", () => {
|
||||
emit({ type: "task", task: task("one", "ready") });
|
||||
expect(backend.notify).not.toHaveBeenCalled();
|
||||
expect(useAgents.getState().unread.has("one")).toBe(false);
|
||||
});
|
||||
|
||||
it("keeps the latest usage limits per provider without marking anything unread", () => {
|
||||
const fiveHour = (usedPercent: number) => [{ window: "five_hour", usedPercent, resetsMs: null }];
|
||||
emit({ type: "limits", provider: "claude", limits: fiveHour(10) });
|
||||
@@ -258,6 +270,7 @@ describe("agent unread activity", () => {
|
||||
describe("agent unread indicators", () => {
|
||||
it("shows a dot on the task and a clickable status count even when all tasks are idle", () => {
|
||||
emit({ type: "task", task: task("one", "ready") });
|
||||
emit({ type: "attention", task: "one", eventId: "one:finished:1", reason: "finished" });
|
||||
render(
|
||||
<>
|
||||
<AgentsView />
|
||||
|
||||
@@ -1407,3 +1407,33 @@
|
||||
color: inherit;
|
||||
cursor: default;
|
||||
}
|
||||
|
||||
/* In-Editor Results: a result set under its statement in the console. */
|
||||
:global(.cm-openidea-db-inline) {
|
||||
padding: var(--space-1) 0 var(--space-2);
|
||||
cursor: default;
|
||||
}
|
||||
.inlineResult {
|
||||
position: relative;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
max-width: 100%;
|
||||
border: 1px solid var(--border);
|
||||
border-radius: var(--radius-control);
|
||||
overflow: hidden;
|
||||
background: var(--bg-editor);
|
||||
font-family: var(--font-ui);
|
||||
font-size: var(--fs-ui);
|
||||
line-height: normal;
|
||||
white-space: normal;
|
||||
}
|
||||
.inlineResult > :first-child {
|
||||
flex: 1;
|
||||
min-height: 0;
|
||||
}
|
||||
.inlineResize {
|
||||
position: absolute;
|
||||
inset: auto 0 0;
|
||||
height: 5px;
|
||||
cursor: row-resize;
|
||||
}
|
||||
@@ -254,7 +254,8 @@ function setSubmittingResult(result: DbQueryResult, on: boolean) {
|
||||
notifyResults();
|
||||
}
|
||||
|
||||
function Result({ tab }: { tab: ResultTab }) {
|
||||
/** A result set's toolbar, grid and pager; `onClose` makes it an in-editor result (closed in place, not pinned). */
|
||||
export function Result({ tab, onClose }: { tab: ResultTab; onClose?: () => void }) {
|
||||
const [view, setView] = useState<"table" | "chart">("table");
|
||||
const [panel, setPanel] = useState<DataPanel | null>(null);
|
||||
const [searchOpen, setSearchOpen] = useState(false);
|
||||
@@ -516,7 +517,7 @@ function Result({ tab }: { tab: ResultTab }) {
|
||||
disabled={busy}
|
||||
onClick={() => void rerunResult(tab.id)}
|
||||
/>
|
||||
<PinButton tab={tab} />
|
||||
{!onClose && <PinButton tab={tab} />}
|
||||
{view === "table" && (
|
||||
<IconButton
|
||||
icon="search"
|
||||
@@ -568,6 +569,7 @@ function Result({ tab }: { tab: ResultTab }) {
|
||||
onClick={(e) => showExport({ x: e.clientX, y: e.clientY })}
|
||||
/>
|
||||
{view === "table" && <PanelToggle panel={panel} onChange={setPanel} />}
|
||||
{onClose && <IconButton icon="close" title="Close" onClick={onClose} />}
|
||||
</Toolbar>
|
||||
{view === "chart" ? (
|
||||
<div className={styles.fill}>
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
.page {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: var(--space-2);
|
||||
color: var(--fg);
|
||||
font-size: var(--fs-ui);
|
||||
}
|
||||
.intro,
|
||||
.hint {
|
||||
margin: 0;
|
||||
color: var(--fg-muted);
|
||||
}
|
||||
.list {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
border: 1px solid var(--border-strong);
|
||||
border-radius: var(--radius-small);
|
||||
padding: var(--space-0-5) 0;
|
||||
}
|
||||
.head,
|
||||
.row {
|
||||
display: grid;
|
||||
grid-template-columns: minmax(160px, 2fr) minmax(140px, 1.5fr) minmax(100px, 1fr) 24px;
|
||||
align-items: center;
|
||||
gap: var(--space-2);
|
||||
min-height: 30px;
|
||||
padding: 0 var(--space-2);
|
||||
}
|
||||
.head {
|
||||
min-height: 24px;
|
||||
color: var(--fg-muted);
|
||||
border-bottom: 1px solid var(--border);
|
||||
}
|
||||
.project {
|
||||
padding-left: var(--space-1);
|
||||
font-weight: 600;
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
/**
|
||||
* Languages & Frameworks › SQL Resolution Scopes: which data source (and schema) SQL in a
|
||||
* folder or file resolves against — completion, inspections, navigation and running
|
||||
* consoles there. The project row applies wherever no folder or file row does.
|
||||
*/
|
||||
import { useEffect, useState } from "react";
|
||||
import { call, commands, type DataSource } from "@/platform/ipc";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { IconButton, Input, Select, T, type SelectOption } from "@/ui";
|
||||
import { useSettingsForm } from "@/workbench/contributions";
|
||||
import { scopePath, validateResolutionScopes, type SqlResolutionScope } from "./resolutionScopes";
|
||||
import styles from "./SqlScopesPage.module.css";
|
||||
|
||||
const KEY = "database.resolutionScopes";
|
||||
const NONE = "";
|
||||
/** An example path, the same in every language. */
|
||||
const PATH_EXAMPLE = "src/main/resources/mapper";
|
||||
|
||||
function useDataSources(): DataSource[] | null {
|
||||
const [sources, setSources] = useState<DataSource[] | null>(null);
|
||||
useEffect(() => {
|
||||
let stale = false;
|
||||
call(commands.dbSources())
|
||||
.then((list) => !stale && setSources(list))
|
||||
.catch(() => !stale && setSources([]));
|
||||
return () => {
|
||||
stale = true;
|
||||
};
|
||||
}, []);
|
||||
return sources;
|
||||
}
|
||||
|
||||
export function SqlScopesPage() {
|
||||
const form = useSettingsForm();
|
||||
const scopes = validateResolutionScopes(form.useValue(KEY));
|
||||
const sources = useDataSources();
|
||||
const set = (next: SqlResolutionScope[]) => form.set(KEY, next);
|
||||
|
||||
const options: SelectOption[] = [
|
||||
{ value: NONE, label: tx("<none>") },
|
||||
...(sources ?? []).map((s) => ({ value: s.id ?? "", label: s.name ?? s.id ?? "", icon: "database" })),
|
||||
];
|
||||
const sourceOptions = (current: string) =>
|
||||
current && !options.some((o) => o.value === current)
|
||||
? [...options, { value: current, label: tx`${current} (missing)` }]
|
||||
: options;
|
||||
|
||||
const projectIndex = scopes.findIndex((s) => !s.path);
|
||||
const project = scopes[projectIndex];
|
||||
const rows = scopes.map((scope, index) => ({ scope, index })).filter(({ index }) => index !== projectIndex);
|
||||
const empty = (): SqlResolutionScope => ({ path: "", dataSource: NONE, schema: "" });
|
||||
|
||||
const patch = (index: number, p: Partial<SqlResolutionScope>) =>
|
||||
set(scopes.map((s, i) => (i === index ? { ...s, ...p } : s)));
|
||||
const setProject = (p: Partial<SqlResolutionScope>) =>
|
||||
project ? patch(projectIndex, p) : set([{ ...empty(), ...p }, ...scopes]);
|
||||
|
||||
return (
|
||||
<div className={styles.page}>
|
||||
<p className={styles.intro}>
|
||||
<T>
|
||||
SQL in these folders and files resolves against the data source: completion, inspections and navigation use
|
||||
its tables, and query consoles run on it unless another data source is picked in their toolbar.
|
||||
</T>
|
||||
</p>
|
||||
<div className={styles.list} role="table" aria-label={tx("SQL Resolution Scopes")}>
|
||||
<div className={styles.head} role="row">
|
||||
<span role="columnheader">
|
||||
<T>Path</T>
|
||||
</span>
|
||||
<span role="columnheader">
|
||||
<T>Data Source</T>
|
||||
</span>
|
||||
<span role="columnheader">
|
||||
<T>Schema</T>
|
||||
</span>
|
||||
<span />
|
||||
</div>
|
||||
<div className={styles.row} role="row">
|
||||
<span className={styles.project} role="cell">
|
||||
<T>Project</T>
|
||||
</span>
|
||||
<Select
|
||||
value={project?.dataSource ?? NONE}
|
||||
options={sourceOptions(project?.dataSource ?? NONE)}
|
||||
onChange={(dataSource) => setProject({ dataSource })}
|
||||
aria-label={tx("Project data source")}
|
||||
/>
|
||||
<Input
|
||||
mono
|
||||
value={project?.schema ?? ""}
|
||||
placeholder={tx("Default")}
|
||||
onChange={(e) => setProject({ schema: e.target.value })}
|
||||
aria-label={tx("Project schema")}
|
||||
/>
|
||||
<span />
|
||||
</div>
|
||||
{rows.map(({ scope, index }) => (
|
||||
<div key={index} className={styles.row} role="row">
|
||||
<Input
|
||||
mono
|
||||
value={scope.path}
|
||||
placeholder={PATH_EXAMPLE}
|
||||
invalid={!scopePath(scope.path)}
|
||||
onChange={(e) => patch(index, { path: e.target.value })}
|
||||
aria-label={tx("Path")}
|
||||
/>
|
||||
<Select
|
||||
value={scope.dataSource}
|
||||
options={sourceOptions(scope.dataSource)}
|
||||
onChange={(dataSource) => patch(index, { dataSource })}
|
||||
aria-label={tx("Data source")}
|
||||
/>
|
||||
<Input
|
||||
mono
|
||||
value={scope.schema}
|
||||
placeholder={tx("Default")}
|
||||
onChange={(e) => patch(index, { schema: e.target.value })}
|
||||
aria-label={tx("Schema")}
|
||||
/>
|
||||
<IconButton
|
||||
icon="trash"
|
||||
size="small"
|
||||
title="Remove"
|
||||
onClick={() => set(scopes.filter((_, i) => i !== index))}
|
||||
/>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
<div>
|
||||
<IconButton
|
||||
icon="plus"
|
||||
size="small"
|
||||
title="Add Folder or File"
|
||||
// The first row without a path is the project's: keep one ahead of the new row.
|
||||
onClick={() => set([...(project ? [] : [empty()]), ...scopes, empty()])}
|
||||
/>
|
||||
</div>
|
||||
<p className={styles.hint}>
|
||||
<T>Paths are relative to the project root. The deepest folder or file that contains a file applies to it.</T>
|
||||
</p>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -39,13 +39,14 @@ import {
|
||||
type Panel,
|
||||
type Tooltip,
|
||||
} from "@codemirror/view";
|
||||
import { useEffect, useMemo, useState } from "react";
|
||||
import { useEffect, useMemo, useRef, useState, type PointerEvent } from "react";
|
||||
import { createRoot } from "react-dom/client";
|
||||
import type { EditorDocContext } from "@/editor/api";
|
||||
import { iconNode } from "@/ui/iconNode";
|
||||
import { call, commands, type DbDriver, type DbSessionContext, type DbStatementOutcome } from "@/platform/ipc";
|
||||
import { shortcutLabel } from "@/platform/keymap";
|
||||
import { IconButton, Select } from "@/ui";
|
||||
import { IconButton, Select, lazyComponent } from "@/ui";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { activeSchema, schemaSwitchable, sourceLabel, splitTarget, targetOf } from "./model";
|
||||
import { loadSavedCatalog, offerIntrospection } from "./introspection";
|
||||
import { analyze, templateContexts, valuesSlot } from "./sql/analyze";
|
||||
@@ -61,6 +62,9 @@ import { snowflakeLanguage } from "./sql/snowflakeHighlight";
|
||||
import {
|
||||
bindConsole,
|
||||
cancelConsole,
|
||||
closeInlineResults,
|
||||
inEditorResults,
|
||||
setInEditorResults,
|
||||
consoleSchema,
|
||||
consoleSource,
|
||||
executeConsole,
|
||||
@@ -84,6 +88,7 @@ import {
|
||||
import styles from "./Database.module.css";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { databaseRequest, projectRequest } from "./requests";
|
||||
import type { ResultTab } from "./store";
|
||||
|
||||
/** `templates` feature's language-data key for finer template contexts. */
|
||||
const TEMPLATE_CONTEXT_KEY = "openideaTemplateContexts";
|
||||
@@ -252,6 +257,213 @@ export async function explainInView(view: EditorView, path: string) {
|
||||
|
||||
const consolePath = Facet.define<string, string>({ combine: (v) => v[0] ?? "" });
|
||||
|
||||
/** An in-editor result and the statement it shows under (mapped through edits). */
|
||||
interface InlineAnchor {
|
||||
id: number;
|
||||
from: number;
|
||||
to: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Where each in-editor result's statement is now and how tall the result is, by result id:
|
||||
* a console's view can be rebuilt (closed and reopened), and its results go back where they were.
|
||||
*/
|
||||
const anchors = new Map<number, { from: number; to: number }>();
|
||||
const heights = new Map<number, number>();
|
||||
const MAX_FIT_HEIGHT = 320;
|
||||
const MIN_HEIGHT = 96;
|
||||
|
||||
/** Toolbar, notice, header row, the rows and room for the floating pager, up to `MAX_FIT_HEIGHT`. */
|
||||
function fitHeight(tab: ResultTab | undefined): number {
|
||||
const rows = tab?.outcome.result?.rows.length ?? 0;
|
||||
return Math.max(MIN_HEIGHT, Math.min(MAX_FIT_HEIGHT, 40 + 24 + 24 + Math.max(rows, 1) * 24 + 56));
|
||||
}
|
||||
|
||||
const setInline = StateEffect.define<InlineAnchor[]>();
|
||||
/** An in-editor result was resized: its widget is redrawn so the editor measures it again. */
|
||||
const resized = StateEffect.define<null>();
|
||||
|
||||
function anchorOf(tab: ResultTab): InlineAnchor {
|
||||
return { id: tab.id, ...(anchors.get(tab.id) ?? { from: tab.outcome.statement.from, to: tab.outcome.statement.to }) };
|
||||
}
|
||||
|
||||
const inlineField = StateField.define<readonly InlineAnchor[]>({
|
||||
create: (state) => {
|
||||
const path = state.facet(consolePath);
|
||||
return useDatabase
|
||||
.getState()
|
||||
.inline.filter((t) => t.path === path)
|
||||
.map(anchorOf)
|
||||
.filter((a) => a.to <= state.doc.length);
|
||||
},
|
||||
update(value, tr) {
|
||||
for (const e of tr.effects) {
|
||||
if (e.is(setInline)) value = e.value;
|
||||
else if (e.is(resized)) value = [...value];
|
||||
}
|
||||
if (!tr.docChanged) return value;
|
||||
const next: InlineAnchor[] = [];
|
||||
for (const a of value) {
|
||||
const from = tr.changes.mapPos(a.from, 1);
|
||||
const to = tr.changes.mapPos(a.to, -1);
|
||||
// The statement was deleted: so is its result (the store drops it in `syncInline`).
|
||||
if (to <= from) continue;
|
||||
anchors.set(a.id, { from, to });
|
||||
next.push({ id: a.id, from, to });
|
||||
}
|
||||
return next;
|
||||
},
|
||||
// Under the statement's last line.
|
||||
provide: (f) =>
|
||||
EditorView.decorations.compute([f], (state) =>
|
||||
Decoration.set(
|
||||
state
|
||||
.field(f)
|
||||
.map((a) =>
|
||||
Decoration.widget({ widget: new InlineResultWidget(a.id, heightOf(a.id)), block: true, side: 1 }).range(
|
||||
state.doc.lineAt(a.to).to,
|
||||
),
|
||||
),
|
||||
true,
|
||||
),
|
||||
),
|
||||
});
|
||||
|
||||
/**
|
||||
* Keeps the view's in-editor results in step with the store: a run's new results show under
|
||||
* their statements (replacing what those statements showed before), closed ones go away.
|
||||
*/
|
||||
const syncInline = ViewPlugin.define((view) => {
|
||||
const path = view.state.facet(consolePath);
|
||||
let destroyed = false;
|
||||
const sync = () => {
|
||||
if (destroyed) return;
|
||||
const current = view.state.field(inlineField);
|
||||
const tabs = useDatabase.getState().inline.filter((t) => t.path === path);
|
||||
const ids = new Set(tabs.map((t) => t.id));
|
||||
const known = new Set(current.map((a) => a.id));
|
||||
const len = view.state.doc.length;
|
||||
const added = tabs
|
||||
.filter((t) => !known.has(t.id))
|
||||
.map(anchorOf)
|
||||
.filter((a) => a.to <= len);
|
||||
const overlaps = (a: InlineAnchor) => added.some((b) => b.from < a.to && a.from < b.to);
|
||||
const replaced = current.filter((a) => ids.has(a.id) && overlaps(a)).map((a) => a.id);
|
||||
const kept = current.filter((a) => ids.has(a.id) && !replaced.includes(a.id));
|
||||
for (const a of current)
|
||||
if (!ids.has(a.id)) {
|
||||
anchors.delete(a.id);
|
||||
heights.delete(a.id);
|
||||
}
|
||||
if (!added.length && kept.length === current.length) return;
|
||||
for (const a of added) anchors.set(a.id, { from: a.from, to: a.to });
|
||||
view.dispatch({ effects: setInline.of([...kept, ...added].sort((a, b) => a.to - b.to || a.id - b.id)) });
|
||||
if (replaced.length) closeInlineResults(replaced);
|
||||
};
|
||||
let shown = view.state.field(inlineField);
|
||||
const stop = useDatabase.subscribe((s, prev) => {
|
||||
if (s.inline !== prev.inline) queueMicrotask(sync);
|
||||
});
|
||||
queueMicrotask(sync);
|
||||
return {
|
||||
// Results whose statements were deleted go too.
|
||||
update(u) {
|
||||
const next = u.state.field(inlineField);
|
||||
if (next === shown) return;
|
||||
const gone = shown.filter((a) => !next.some((b) => b.id === a.id)).map((a) => a.id);
|
||||
shown = next;
|
||||
if (gone.length && u.docChanged) queueMicrotask(() => closeInlineResults(gone));
|
||||
},
|
||||
destroy: () => {
|
||||
destroyed = true;
|
||||
stop();
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
function heightOf(id: number): number {
|
||||
return heights.get(id) ?? fitHeight(useDatabase.getState().inline.find((r) => r.id === id));
|
||||
}
|
||||
|
||||
const InlineGrid = lazyComponent(() => import("./ResultsView").then((m) => m.Result));
|
||||
|
||||
function InlineResult({ id, view }: { id: number; view: EditorView }) {
|
||||
const tab = useDatabase((s) => s.inline.find((r) => r.id === id));
|
||||
const [height, setHeight] = useState(() => heightOf(id));
|
||||
const drag = useRef<{ y: number; height: number } | null>(null);
|
||||
const measured = useRef(height);
|
||||
useEffect(() => {
|
||||
if (measured.current === height) return;
|
||||
measured.current = height;
|
||||
view.dispatch({ effects: resized.of(null) });
|
||||
}, [height, view]);
|
||||
if (!tab) return null;
|
||||
const onPointerDown = (e: PointerEvent<HTMLDivElement>) => {
|
||||
e.preventDefault();
|
||||
e.currentTarget.setPointerCapture(e.pointerId);
|
||||
drag.current = { y: e.clientY, height };
|
||||
};
|
||||
const onPointerMove = (e: PointerEvent<HTMLDivElement>) => {
|
||||
if (!drag.current) return;
|
||||
const next = Math.max(MIN_HEIGHT, Math.round(drag.current.height + e.clientY - drag.current.y));
|
||||
heights.set(id, next);
|
||||
setHeight(next);
|
||||
};
|
||||
return (
|
||||
<div className={styles.inlineResult} style={{ height }}>
|
||||
<InlineGrid tab={tab} onClose={() => closeInlineResults([id])} />
|
||||
<div
|
||||
className={styles.inlineResize}
|
||||
role="separator"
|
||||
aria-orientation="horizontal"
|
||||
aria-label={tx("Resize")}
|
||||
onPointerDown={onPointerDown}
|
||||
onPointerMove={onPointerMove}
|
||||
onPointerUp={() => (drag.current = null)}
|
||||
/>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
const inlineRoots = new WeakMap<HTMLElement, ReturnType<typeof createRoot>>();
|
||||
|
||||
class InlineResultWidget extends WidgetType {
|
||||
constructor(
|
||||
readonly id: number,
|
||||
readonly height: number,
|
||||
) {
|
||||
super();
|
||||
}
|
||||
eq(other: InlineResultWidget) {
|
||||
return other.id === this.id && other.height === this.height;
|
||||
}
|
||||
/** A resized result keeps its DOM (and grid state); only the editor's measurement changes. */
|
||||
updateDOM(dom: HTMLElement) {
|
||||
return dom.dataset.result === String(this.id);
|
||||
}
|
||||
get estimatedHeight() {
|
||||
return this.height + 12;
|
||||
}
|
||||
toDOM(view: EditorView) {
|
||||
const dom = document.createElement("div");
|
||||
dom.className = "cm-openidea-db-inline";
|
||||
dom.contentEditable = "false";
|
||||
dom.dataset.result = String(this.id);
|
||||
const root = createRoot(dom);
|
||||
inlineRoots.set(dom, root);
|
||||
root.render(<InlineResult id={this.id} view={view} />);
|
||||
return dom;
|
||||
}
|
||||
destroy(dom: HTMLElement) {
|
||||
const root = inlineRoots.get(dom);
|
||||
inlineRoots.delete(dom);
|
||||
queueMicrotask(() => root?.unmount());
|
||||
}
|
||||
ignoreEvent() {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
|
||||
const sources = useDatabase((s) => s.sources);
|
||||
const loaded = useDatabase((s) => s.loaded);
|
||||
@@ -261,6 +473,9 @@ function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
|
||||
const manual = useDatabase((s) => !!bound && s.manualCommit.has(bound));
|
||||
const pending = useDatabase((s) => !!bound && s.pendingTx.has(bound));
|
||||
const databases = useDatabase((s) => s.databases);
|
||||
const inEditor = useProject((s) => inEditorResults(s.settings));
|
||||
// SQL resolution scopes in the settings can move the console to another data source.
|
||||
useProject((s) => s.settings);
|
||||
const boundId = bound ? splitTarget(bound).id : null;
|
||||
const supportsTransactions = sourceById(boundId)?.driver !== "clickhouse";
|
||||
const sqlServer = sourceById(boundId)?.driver === "sqlServer";
|
||||
@@ -348,6 +563,12 @@ function ConsoleBar({ path, view }: { path: string; view: EditorView }) {
|
||||
/>
|
||||
<span className={styles.toolbarSeparator} />
|
||||
<IconButton icon="history" title="Browse Query History" disabled={!bound} onClick={() => openHistory(path)} />
|
||||
<IconButton
|
||||
icon="db-in-editor-results"
|
||||
title="In-Editor Results"
|
||||
aria-pressed={inEditor}
|
||||
onClick={() => void setInEditorResults(!inEditor)}
|
||||
/>
|
||||
<span className={styles.toolbarSeparator} />
|
||||
<Select
|
||||
aria-label="Row limit"
|
||||
@@ -779,6 +1000,8 @@ export function consoleExtension(ctx: EditorDocContext): Extension {
|
||||
consolePath.of(ctx.path),
|
||||
runField,
|
||||
runGutter,
|
||||
inlineField,
|
||||
syncInline,
|
||||
showPanel.of(consolePanel(ctx.path)),
|
||||
EditorState.languageData.of(() => [
|
||||
{ openideaCompletion: completionSource(ctx.path), [TEMPLATE_CONTEXT_KEY]: templateContextsAt(ctx.path) },
|
||||
|
||||
@@ -0,0 +1,136 @@
|
||||
import { act } from "@testing-library/react";
|
||||
import { EditorState } from "@codemirror/state";
|
||||
import { EditorView } from "@codemirror/view";
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { consoleExtension } from "./console";
|
||||
import { SQL_LANGUAGE } from "./sqlLanguage";
|
||||
import { executeConsole, rerunResult, useDatabase } from "./store";
|
||||
|
||||
const backend = vi.hoisted(() => ({ execute: vi.fn(), statements: vi.fn() }));
|
||||
|
||||
vi.mock("@/platform/ipc", async (importOriginal) => {
|
||||
const actual = await importOriginal<typeof import("@/platform/ipc")>();
|
||||
return {
|
||||
...actual,
|
||||
commands: { ...actual.commands, dbExecute: backend.execute, dbStatements: backend.statements },
|
||||
};
|
||||
});
|
||||
|
||||
vi.mock("@tanstack/react-virtual", () => ({
|
||||
useVirtualizer: ({ count }: { count: number }) => ({
|
||||
getTotalSize: () => count * 24,
|
||||
getVirtualItems: () => Array.from({ length: count }, (_, index) => ({ index, start: index * 24, key: index })),
|
||||
scrollToIndex: () => {},
|
||||
}),
|
||||
}));
|
||||
|
||||
const PATH = "/p/console.sql";
|
||||
const initial = useDatabase.getState();
|
||||
let runs = 0;
|
||||
|
||||
beforeEach(() => {
|
||||
runs = 0;
|
||||
useProject.setState({
|
||||
project: { name: "p", root: "/p", trusted: true } as never,
|
||||
settings: { database: { inEditorResults: true } } as never,
|
||||
});
|
||||
useDatabase.setState({
|
||||
...initial,
|
||||
loaded: true,
|
||||
sources: [{ id: "pg", name: "Local", driver: "postgres", readOnly: false }],
|
||||
completion: { pg: { defaultSchema: "public", tables: [], foreignKeys: [] } },
|
||||
consoles: { [PATH]: "pg" },
|
||||
results: [],
|
||||
inline: [],
|
||||
});
|
||||
backend.statements.mockImplementation((_id: unknown, text: string, from: number, to: number) => {
|
||||
let at = 0;
|
||||
const all = text.split(";").flatMap((part) => {
|
||||
const start = at + part.length - part.trimStart().length;
|
||||
at += part.length + 1;
|
||||
const st = part.trim();
|
||||
return st ? [{ from: start, to: start + st.length, text: st }] : [];
|
||||
});
|
||||
const picked = from === to ? all.filter((s) => s.from <= from && from <= s.to + 1) : all;
|
||||
return Promise.resolve({ status: "ok", data: picked });
|
||||
});
|
||||
backend.execute.mockImplementation((_r: unknown, _id: unknown, statements: Array<{ text: string }>) => {
|
||||
runs++;
|
||||
return Promise.resolve({
|
||||
status: "ok",
|
||||
data: statements.map((st) => ({
|
||||
statement: st,
|
||||
result: {
|
||||
statement: st.text,
|
||||
columns: [{ name: "v", typeName: "text" }],
|
||||
rows: [[`${st.text} #${runs}`]],
|
||||
affected: null,
|
||||
hasMore: false,
|
||||
elapsedMs: 1,
|
||||
executionMs: 1,
|
||||
},
|
||||
error: null,
|
||||
})),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
document.body.innerHTML = "";
|
||||
});
|
||||
|
||||
describe("In-Editor Results", () => {
|
||||
it("keeps a run's result sets out of the result tabs, and re-runs them in place", async () => {
|
||||
await executeConsole(PATH, "SELECT 1; SELECT 2", 0, 18);
|
||||
const st = useDatabase.getState();
|
||||
expect(st.results).toEqual([]);
|
||||
expect(st.inline.map((r) => r.outcome.statement.text)).toEqual(["SELECT 1", "SELECT 2"]);
|
||||
const id = st.inline[0]!.id;
|
||||
await rerunResult(id);
|
||||
expect(useDatabase.getState().inline[0]!.outcome.result!.rows).toEqual([["SELECT 1 #2"]]);
|
||||
expect(useDatabase.getState().inline[0]!.id).toBe(id);
|
||||
});
|
||||
|
||||
it("goes to the result tabs while the setting is off", async () => {
|
||||
useProject.setState({ settings: {} as never });
|
||||
await executeConsole(PATH, "SELECT 1", 0, 0);
|
||||
expect(useDatabase.getState().inline).toEqual([]);
|
||||
expect(useDatabase.getState().results).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("shows each result under its statement, replaces it on a re-run and drops it with the statement", async () => {
|
||||
const parent = document.createElement("div");
|
||||
document.body.append(parent);
|
||||
const doc = "SELECT 1;\nSELECT 2;\n";
|
||||
const view = new EditorView({
|
||||
parent,
|
||||
state: EditorState.create({
|
||||
doc,
|
||||
extensions: consoleExtension({ language: SQL_LANGUAGE, path: PATH } as never),
|
||||
}),
|
||||
});
|
||||
const widgets = () => [...view.dom.querySelectorAll(".cm-openidea-db-inline")];
|
||||
const ids = () => useDatabase.getState().inline.map((r) => r.id);
|
||||
|
||||
await act(async () => void (await executeConsole(PATH, view.state.doc.toString(), 0, doc.length)));
|
||||
await act(async () => {});
|
||||
expect(widgets()).toHaveLength(2);
|
||||
const [first, second] = ids();
|
||||
|
||||
// Running the first statement again replaces only its own result.
|
||||
await act(async () => void (await executeConsole(PATH, view.state.doc.toString(), 0, 0)));
|
||||
await act(async () => {});
|
||||
expect(ids()).toHaveLength(2);
|
||||
expect(ids()).toContain(second);
|
||||
expect(ids()).not.toContain(first);
|
||||
expect(widgets()).toHaveLength(2);
|
||||
|
||||
// Deleting the second statement closes its result.
|
||||
await act(async () => view.dispatch({ changes: { from: 10, to: 19 } }));
|
||||
await act(async () => {});
|
||||
expect(ids()).not.toContain(second);
|
||||
expect(widgets()).toHaveLength(1);
|
||||
view.destroy();
|
||||
});
|
||||
});
|
||||
@@ -39,6 +39,8 @@ import {
|
||||
RESULTS_VIEW,
|
||||
consoleSource,
|
||||
consoleTints,
|
||||
inEditorResults,
|
||||
setInEditorResults,
|
||||
loadSources,
|
||||
connect,
|
||||
loadSchemas,
|
||||
@@ -79,6 +81,8 @@ function tableTarget(arg: unknown): TableCommandTarget {
|
||||
return { rows: activeCellGrid()?.selectedRows() ?? [], editor: null };
|
||||
}
|
||||
|
||||
export { activateSettingsPages } from "./settingsPages";
|
||||
|
||||
export function activate(): () => void {
|
||||
const disposers = [
|
||||
onIdeEvent("dbSourcesChanged", () => {
|
||||
@@ -135,6 +139,7 @@ export function activate(): () => void {
|
||||
objects: {},
|
||||
completion: {},
|
||||
results: [],
|
||||
inline: [],
|
||||
output: [],
|
||||
activeResult: null,
|
||||
selectedSource: null,
|
||||
@@ -262,6 +267,16 @@ export function activate(): () => void {
|
||||
await (await import("./console")).executeInView(e.view, e.ctx.path);
|
||||
},
|
||||
},
|
||||
{
|
||||
id: "db.toggleInEditorResults",
|
||||
title: "In-Editor Results",
|
||||
description: "Show query results in the editor, under the statements that produced them",
|
||||
category: "Tools",
|
||||
icon: "db-in-editor-results",
|
||||
keywords: ["inline", "results", "console", "grid"],
|
||||
toggled: () => inEditorResults(),
|
||||
run: () => setInEditorResults(!inEditorResults()),
|
||||
},
|
||||
{
|
||||
id: "db.executeScript",
|
||||
title: "Execute SQL Script",
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
import { beforeEach, describe, expect, it } from "vitest";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { resolutionScopeOf, validateResolutionScopes } from "./resolutionScopes";
|
||||
import { bindConsole, consoleSchema, consoleSource, useDatabase } from "./store";
|
||||
|
||||
const scopes = validateResolutionScopes([
|
||||
{ path: "", dataSource: "main", schema: "" },
|
||||
{ path: "./src/main/resources/mapper/", dataSource: "orders", schema: "sales" },
|
||||
{ path: "src/main/resources/mapper/legacy/Old.xml", dataSource: "legacy", schema: "" },
|
||||
{ path: "src/gone", dataSource: "removed", schema: "" },
|
||||
]);
|
||||
|
||||
describe("SQL resolution scopes", () => {
|
||||
it("normalises paths and picks the deepest folder or file covering a file, else the project row", () => {
|
||||
expect(scopes[1]!.path).toBe("src/main/resources/mapper");
|
||||
const at = (rel: string) => resolutionScopeOf(`/p/${rel}`, "/p", scopes)?.dataSource;
|
||||
expect(at("src/main/resources/mapper/UserMapper.xml")).toBe("orders");
|
||||
expect(at("src/main/resources/mapper/legacy/Old.xml")).toBe("legacy");
|
||||
expect(at("src/main/resources/mapper/legacy/New.xml")).toBe("orders");
|
||||
// A sibling folder whose name starts the same is not inside.
|
||||
expect(at("src/main/resources/mapperx/A.xml")).toBe("main");
|
||||
expect(resolutionScopeOf("/elsewhere/a.sql", "/p", scopes)).toBeNull();
|
||||
});
|
||||
|
||||
it("skips rows whose data source no longer exists", () => {
|
||||
const known = (id: string) => id !== "removed";
|
||||
expect(resolutionScopeOf("/p/src/gone/a.sql", "/p", scopes, known)?.dataSource).toBe("main");
|
||||
});
|
||||
});
|
||||
|
||||
describe("the data source a SQL file resolves against", () => {
|
||||
beforeEach(() => {
|
||||
useProject.setState({
|
||||
project: { name: "p", root: "/p", trusted: true } as never,
|
||||
settings: { database: { resolutionScopes: scopes } } as never,
|
||||
});
|
||||
useDatabase.setState({
|
||||
sources: ["main", "orders", "legacy"].map((id) => ({ id, name: id, driver: "postgres" as const })),
|
||||
consoles: {},
|
||||
consoleSchemas: {},
|
||||
completion: { orders: { defaultSchema: "public", tables: [], foreignKeys: [] } },
|
||||
});
|
||||
});
|
||||
|
||||
it("is the one picked in its toolbar, else its scope's (with the scope's schema)", () => {
|
||||
const file = "/p/src/main/resources/mapper/UserMapper.xml";
|
||||
expect(consoleSource(file)).toBe("orders");
|
||||
expect(consoleSchema(file)).toBe("sales");
|
||||
bindConsole(file, "legacy");
|
||||
expect(consoleSource(file)).toBe("legacy");
|
||||
bindConsole(file, null);
|
||||
expect(consoleSource("/p/scratch.sql")).toBe("main");
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* Languages & Frameworks › SQL Resolution Scopes: the data source (and schema) SQL in a
|
||||
* file or folder resolves against. The most specific path wins; an empty path is the
|
||||
* whole project.
|
||||
*/
|
||||
export interface SqlResolutionScope {
|
||||
/** Project-relative file or folder, `/`-separated; empty for the whole project. */
|
||||
path: string;
|
||||
dataSource: string;
|
||||
schema: string;
|
||||
}
|
||||
|
||||
const str = (v: unknown) => (typeof v === "string" ? v : "");
|
||||
|
||||
/** Normalises a project-relative path: `/`-separated, without `./` or surrounding slashes. */
|
||||
export function scopePath(path: string): string {
|
||||
return path
|
||||
.trim()
|
||||
.replace(/\\/g, "/")
|
||||
.replace(/^(\.\/)+/, "")
|
||||
.replace(/^\/+|\/+$/g, "");
|
||||
}
|
||||
|
||||
export function validateResolutionScopes(raw: unknown): SqlResolutionScope[] {
|
||||
if (!Array.isArray(raw)) return [];
|
||||
return raw.flatMap((r) => {
|
||||
if (!r || typeof r !== "object") return [];
|
||||
const o = r as Record<string, unknown>;
|
||||
return [{ path: scopePath(str(o.path)), dataSource: str(o.dataSource), schema: str(o.schema).trim() }];
|
||||
});
|
||||
}
|
||||
|
||||
/** The scopes in raw settings (`database.resolutionScopes`). */
|
||||
export function resolutionScopesOf(settings: unknown): SqlResolutionScope[] {
|
||||
const database = (settings as { database?: { resolutionScopes?: unknown } } | null)?.database;
|
||||
return validateResolutionScopes(database?.resolutionScopes);
|
||||
}
|
||||
|
||||
/**
|
||||
* The scope of `file` (absolute, under project `root`) among `scopes` whose data source
|
||||
* `known` accepts: the deepest folder or the file itself, else the project's row.
|
||||
*/
|
||||
export function resolutionScopeOf(
|
||||
file: string,
|
||||
root: string,
|
||||
scopes: readonly SqlResolutionScope[],
|
||||
known: (dataSource: string) => boolean = () => true,
|
||||
): SqlResolutionScope | null {
|
||||
const base = root.replace(/\\/g, "/").replace(/\/+$/, "");
|
||||
const normalized = file.replace(/\\/g, "/");
|
||||
if (!base || !normalized.startsWith(`${base}/`)) return null;
|
||||
const rel = normalized.slice(base.length + 1);
|
||||
let best: SqlResolutionScope | null = null;
|
||||
for (const scope of scopes) {
|
||||
if (!scope.dataSource || !known(scope.dataSource)) continue;
|
||||
const p = scope.path;
|
||||
const covers = !p || rel === p || rel.startsWith(`${p}/`);
|
||||
if (covers && (!best || p.length > best.path.length)) best = scope;
|
||||
}
|
||||
return best;
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
import { lazyComponent } from "@/ui";
|
||||
import { registerSettingsPage } from "@/workbench/contributions";
|
||||
|
||||
/** Settings › Languages & Frameworks › SQL Resolution Scopes (also used by the Settings window). */
|
||||
export function activateSettingsPages(): () => void {
|
||||
return registerSettingsPage({
|
||||
id: "languages.sqlResolutionScopes",
|
||||
title: "SQL Resolution Scopes",
|
||||
group: "Languages & Frameworks",
|
||||
order: 404.5,
|
||||
projectScope: true,
|
||||
defaultScope: "project",
|
||||
keywords: ["sql", "data source", "database", "schema", "mybatis", "mapper", "resolve", "dialect"],
|
||||
component: lazyComponent(() => import("./SqlScopesPage").then((m) => m.SqlScopesPage)),
|
||||
});
|
||||
}
|
||||
@@ -56,6 +56,7 @@ import { formatted } from "./sql/format";
|
||||
import { bindParams, findParams } from "./sql/params";
|
||||
import { isReadOnlyQuery } from "./sql/readOnly";
|
||||
import { pageFetch } from "./resultView";
|
||||
import { resolutionScopeOf, resolutionScopesOf, type SqlResolutionScope } from "./resolutionScopes";
|
||||
import { databaseRequest, invalidateDatabaseRequests, projectRequest } from "./requests";
|
||||
import { tx } from "@/platform/i18n";
|
||||
|
||||
@@ -87,6 +88,18 @@ export interface ResultTab {
|
||||
total?: number | null;
|
||||
/** Kept when the console runs again (Pin Tab); results otherwise replace the console's last ones. */
|
||||
pinned?: boolean;
|
||||
/** Shown in the editor under its statement (In-Editor Results), not as a result tab. */
|
||||
inline?: boolean;
|
||||
}
|
||||
|
||||
/** Database › In-Editor Results: result sets show under their statements instead of in result tabs. */
|
||||
export function inEditorResults(settings: unknown = useProject.getState().settings): boolean {
|
||||
return (settings as { database?: { inEditorResults?: unknown } } | null)?.database?.inEditorResults === true;
|
||||
}
|
||||
|
||||
export async function setInEditorResults(on: boolean): Promise<void> {
|
||||
const settings = await call(commands.settingsSet("global", "database.inEditorResults", JSON.stringify(on)));
|
||||
useProject.setState({ settings });
|
||||
}
|
||||
|
||||
/** One line of the consoles' Output log (IDEA's Database Console output). */
|
||||
@@ -167,6 +180,8 @@ interface DatabaseState {
|
||||
separateProceduresAndFunctions: boolean;
|
||||
completion: Record<string, DbCompletion>;
|
||||
results: ResultTab[];
|
||||
/** Results shown in the editor under their statements (In-Editor Results), oldest first. */
|
||||
inline: ResultTab[];
|
||||
/** Result tab id, or `OUTPUT_TAB`. */
|
||||
activeResult: number | null;
|
||||
output: OutputLine[];
|
||||
@@ -234,6 +249,7 @@ export const useDatabase = create<DatabaseState>(() => ({
|
||||
separateProceduresAndFunctions: readSeparateProceduresAndFunctions(),
|
||||
completion: {},
|
||||
results: [],
|
||||
inline: [],
|
||||
activeResult: null,
|
||||
output: [],
|
||||
running: {},
|
||||
@@ -869,7 +885,10 @@ export function bindConsole(path: string, id: string | null) {
|
||||
export function consoleSchema(path: string): string {
|
||||
const s = useDatabase.getState();
|
||||
const id = consoleSource(path);
|
||||
return activeSchema(s.consoleSchemas[path], id ? s.completion[id]?.defaultSchema : undefined);
|
||||
// A scope's schema applies while the console is on that scope's data source.
|
||||
const scope = s.consoles[path] ? null : scopeOf(path);
|
||||
const picked = s.consoleSchemas[path] ?? (scope && scope.dataSource === id ? scope.schema : undefined);
|
||||
return activeSchema(picked || undefined, id ? s.completion[id]?.defaultSchema : undefined);
|
||||
}
|
||||
|
||||
/** Sets (or clears, for `null`) the console's active schema and remembers it per console file. */
|
||||
@@ -887,11 +906,26 @@ export function setConsoleSchema(path: string, schema: string | null) {
|
||||
});
|
||||
}
|
||||
|
||||
/** The data source a console / SQL file runs on: its binding, else the only data source. */
|
||||
/** The SQL resolution scope of file `path` (Languages & Frameworks › SQL Resolution Scopes), if any. */
|
||||
function scopeOf(path: string): SqlResolutionScope | null {
|
||||
const { project, settings } = useProject.getState();
|
||||
if (!project) return null;
|
||||
const sources = useDatabase.getState().sources;
|
||||
return resolutionScopeOf(path, project.root, resolutionScopesOf(settings), (id) =>
|
||||
sources.some((x) => x.id === splitTarget(id).id),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* The data source a console / SQL file runs on and resolves against: the one picked in its
|
||||
* toolbar, else its SQL resolution scope's, else the only data source.
|
||||
*/
|
||||
export function consoleSource(path: string): string | null {
|
||||
const s = useDatabase.getState();
|
||||
const bound = s.consoles[path];
|
||||
if (bound && s.sources.some((x) => x.id === splitTarget(bound).id)) return bound;
|
||||
const scope = scopeOf(path);
|
||||
if (scope) return scope.dataSource;
|
||||
return s.sources.length === 1 ? (s.sources[0]!.id ?? null) : null;
|
||||
}
|
||||
|
||||
@@ -1141,6 +1175,10 @@ export async function executeConsole(
|
||||
const title = index === 1 ? tx`Result ${n}` : tx`Result ${n}-${index}`;
|
||||
return { id: nextTab++, title, path, sourceId: id, schema, outcome, page: 0, pageSize };
|
||||
});
|
||||
if (inEditorResults()) {
|
||||
useDatabase.setState((s) => ({ inline: [...s.inline, ...tabs.map((t) => ({ ...t, inline: true }))] }));
|
||||
return outcomes;
|
||||
}
|
||||
const failed = outcomes.some((o) => o.error);
|
||||
useDatabase.setState((s) => ({
|
||||
results: replaceResults(s.results, path, tabs),
|
||||
@@ -1282,7 +1320,7 @@ export async function openObjectDdl(id: string, schema: string, kind: DbObjectKi
|
||||
|
||||
/** Re-runs the statement of result tab `tabId`, replacing its rows (a plan tab explains it again). */
|
||||
export async function rerunResult(tabId: number): Promise<void> {
|
||||
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
|
||||
const tab = findResult(tabId);
|
||||
if (!tab || tab.busy) return;
|
||||
if (tab.plan) {
|
||||
patchResult(tabId, { busy: true });
|
||||
@@ -1305,8 +1343,16 @@ export function pageable(tab: ResultTab): boolean {
|
||||
return !tab.plan && isReadOnlyQuery(tab.outcome.statement.text, sourceById(tab.sourceId)?.driver ?? "sqlite");
|
||||
}
|
||||
|
||||
/** Result tab `tabId`, in the Services view or in an editor. */
|
||||
export function findResult(tabId: number): ResultTab | undefined {
|
||||
const st = useDatabase.getState();
|
||||
return st.results.find((r) => r.id === tabId) ?? st.inline.find((r) => r.id === tabId);
|
||||
}
|
||||
|
||||
function patchResult(tabId: number, p: Partial<ResultTab>) {
|
||||
useDatabase.setState((s) => ({ results: s.results.map((r) => (r.id === tabId ? { ...r, ...p } : r)) }));
|
||||
const patch = (list: ResultTab[]) =>
|
||||
list.some((r) => r.id === tabId) ? list.map((r) => (r.id === tabId ? { ...r, ...p } : r)) : list;
|
||||
useDatabase.setState((s) => ({ results: patch(s.results), inline: patch(s.inline) }));
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -1315,7 +1361,7 @@ function patchResult(tabId: number, p: Partial<ResultTab>) {
|
||||
* `rerun` also forgets the counted total.
|
||||
*/
|
||||
export async function loadResultPage(tabId: number, page: number, pageSize: number, rerun = false): Promise<void> {
|
||||
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
|
||||
const tab = findResult(tabId);
|
||||
if (!tab || tab.busy || tab.plan) return;
|
||||
if (page > 0 && !pageable(tab)) return;
|
||||
patchResult(tabId, { busy: true });
|
||||
@@ -1363,7 +1409,7 @@ export function countable(tab: ResultTab): boolean {
|
||||
|
||||
/** Counts the rows of result tab `tabId`'s whole query (the pager's "of 501+"). */
|
||||
export async function countResult(tabId: number): Promise<number | null> {
|
||||
const tab = useDatabase.getState().results.find((r) => r.id === tabId);
|
||||
const tab = findResult(tabId);
|
||||
if (!tab || tab.busy || !countable(tab)) return null;
|
||||
const text = countQuery(tab.outcome.statement.text)!;
|
||||
patchResult(tabId, { busy: true });
|
||||
@@ -1468,6 +1514,12 @@ export function closeResult(id: number) {
|
||||
});
|
||||
}
|
||||
|
||||
/** Closes in-editor results `ids`. */
|
||||
export function closeInlineResults(ids: readonly number[]) {
|
||||
if (!ids.length) return;
|
||||
useDatabase.setState((s) => ({ inline: s.inline.filter((r) => !ids.includes(r.id)) }));
|
||||
}
|
||||
|
||||
export function pinResult(id: number, pinned: boolean) {
|
||||
patchResult(id, { pinned });
|
||||
}
|
||||
@@ -20,6 +20,7 @@ const proc = (p: Partial<AttachableProcess> & Pick<AttachableProcess, "pid" | "k
|
||||
name: p.kind,
|
||||
commandLine: `${p.kind} app`,
|
||||
adapter: {
|
||||
unity: "unity",
|
||||
java: "java-debug",
|
||||
node: "js-debug",
|
||||
python: "debugpy",
|
||||
@@ -49,6 +50,14 @@ const list = [
|
||||
];
|
||||
|
||||
describe("Attach to Process popup model", () => {
|
||||
it("attaches the chosen Unity Editor by its exact ID without launching or using a native adapter", async () => {
|
||||
const launch = await attachConfig(proc({ pid: 1234, kind: "unity", name: "Unity Editor" }), "/game");
|
||||
expect(launch).toMatchObject({ adapter: "unity", request: "attach", program: null, cwd: "/game" });
|
||||
expect(JSON.parse(launch.extraJson!)).toEqual({
|
||||
name: "Unity Editor (1234)",
|
||||
__exceptionOptions: [],
|
||||
});
|
||||
});
|
||||
it("groups processes by debugger in IDEA's order with counts", () => {
|
||||
const rows = attachRows(list, "");
|
||||
expect(rows.filter((r) => r.kind === "group").map((r) => r.kind === "group" && `${r.label}:${r.count}`)).toEqual([
|
||||
|
||||
@@ -12,6 +12,7 @@ describe("missing debug adapters", () => {
|
||||
});
|
||||
|
||||
it("offers the managed install of a missing adapter binary", () => {
|
||||
expect(missingAdapter("unity", unavailable("debug adapter `unity` not found"))?.tool).toBe("unity-debug");
|
||||
const e = unavailable(
|
||||
"debug adapter `js-debug` not found (`js-debug-adapter` is neither installed by OpenIDEA nor on PATH)",
|
||||
);
|
||||
|
||||
@@ -0,0 +1,142 @@
|
||||
import { afterEach, beforeEach, expect, it, vi } from "vitest";
|
||||
import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
|
||||
import type { AttachableProcess, ProjectInfo, RunConfig } from "@/platform/ipc";
|
||||
|
||||
const mocks = vi.hoisted(() => ({ discover: vi.fn(), generic: vi.fn(), start: vi.fn(), install: vi.fn() }));
|
||||
vi.mock("@/platform/ipc", async (original) => {
|
||||
const real = await original<typeof import("@/platform/ipc")>();
|
||||
return {
|
||||
...real,
|
||||
isTauri: () => true,
|
||||
commands: {
|
||||
...real.commands,
|
||||
debugUnityProcesses: mocks.discover,
|
||||
debugAttachableProcesses: mocks.generic,
|
||||
},
|
||||
};
|
||||
});
|
||||
vi.mock("../state", async (original) => ({
|
||||
...(await original<typeof import("../state")>()),
|
||||
startSession: mocks.start,
|
||||
}));
|
||||
|
||||
import { registerAction } from "@/platform/actions";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { openAttachPopup, installAttachAdapter } from "../attachPopup";
|
||||
import { DebuggerOverlays } from "../ui/Overlays";
|
||||
import { useOverlays } from "../ui/popoverStore";
|
||||
|
||||
const editor: AttachableProcess = {
|
||||
pid: 42,
|
||||
name: "Unity Editor",
|
||||
commandLine: "/game",
|
||||
adapter: "unity",
|
||||
kind: "unity",
|
||||
host: null,
|
||||
port: null,
|
||||
};
|
||||
const ok = (data: AttachableProcess[]) => ({ status: "ok" as const, data });
|
||||
function deferred() {
|
||||
let resolve!: (result: ReturnType<typeof ok>) => void;
|
||||
const promise = new Promise<ReturnType<typeof ok>>((r) => {
|
||||
resolve = r;
|
||||
});
|
||||
return { promise, resolve };
|
||||
}
|
||||
let dispose: () => void;
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
useProject.setState({ project: { root: "/game" } as ProjectInfo });
|
||||
useOverlays.setState({ attach: null });
|
||||
mocks.discover.mockResolvedValue(ok([editor]));
|
||||
mocks.start.mockResolvedValue(1);
|
||||
mocks.install.mockResolvedValue(undefined);
|
||||
dispose = registerAction({ id: "tools.install", title: "Install", run: mocks.install });
|
||||
});
|
||||
afterEach(() => {
|
||||
cleanup();
|
||||
dispose();
|
||||
useOverlays.setState({ attach: null });
|
||||
useProject.setState({ project: null });
|
||||
});
|
||||
|
||||
it("selects the requested Unity process and starts a non-rerunnable attach session", async () => {
|
||||
const otherEditor = { ...editor, pid: 84, commandLine: "/other-game" };
|
||||
mocks.discover.mockResolvedValueOnce(ok([otherEditor, editor]));
|
||||
await openAttachPopup("unity");
|
||||
render(<DebuggerOverlays />);
|
||||
expect(screen.getByRole("dialog", { name: "Attach to Unity Process" })).toBeTruthy();
|
||||
expect(screen.getByText(/switch to Debug Mode/)).toBeTruthy();
|
||||
fireEvent.keyDown(screen.getByRole("textbox", { name: "Filter processes" }), { key: "ArrowDown" });
|
||||
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
|
||||
await waitFor(() =>
|
||||
expect(mocks.start).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
request: "attach",
|
||||
adapter: "unity",
|
||||
cwd: "/game",
|
||||
extraJson: expect.stringContaining("Unity Editor (42)"),
|
||||
}),
|
||||
{ rerunnable: false },
|
||||
),
|
||||
);
|
||||
expect(mocks.generic).not.toHaveBeenCalled();
|
||||
expect(useOverlays.getState().attach).toBeNull();
|
||||
});
|
||||
|
||||
it("associates the selected run configuration after refreshing the picker", async () => {
|
||||
const runConfig = { id: "unity-editor", name: "Unity Editor", kind: "unity-editor" } as RunConfig;
|
||||
await openAttachPopup("unity", runConfig);
|
||||
render(<DebuggerOverlays />);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Refresh" }));
|
||||
await waitFor(() => expect(useOverlays.getState().attach?.processes).toEqual([editor]));
|
||||
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
|
||||
await waitFor(() => expect(mocks.start).toHaveBeenCalledWith(expect.anything(), { rerunnable: false, runConfig }));
|
||||
});
|
||||
|
||||
it("offers installation for a missing adapter and retries discovery afterwards", async () => {
|
||||
mocks.discover.mockResolvedValueOnce({
|
||||
status: "error",
|
||||
error: { kind: "unavailable", message: "debug adapter `unity` not found" },
|
||||
});
|
||||
await openAttachPopup("unity");
|
||||
render(<DebuggerOverlays />);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Install Unity Debugger" }));
|
||||
await waitFor(() => expect(useOverlays.getState().attach?.processes).toEqual([editor]));
|
||||
expect(mocks.install).toHaveBeenCalledWith(expect.objectContaining({ arg: "unity-debug" }));
|
||||
});
|
||||
|
||||
it("does not replace a refreshed picker with an older discovery response", async () => {
|
||||
const old = deferred();
|
||||
mocks.discover.mockReturnValueOnce(old.promise);
|
||||
const first = openAttachPopup("unity");
|
||||
await openAttachPopup("unity");
|
||||
old.resolve(ok([]));
|
||||
await first;
|
||||
expect(useOverlays.getState().attach?.processes).toEqual([editor]);
|
||||
});
|
||||
|
||||
it("does not reopen a cancelled picker when discovery finishes", async () => {
|
||||
const pending = deferred();
|
||||
mocks.discover.mockReturnValueOnce(pending.promise);
|
||||
const request = openAttachPopup("unity");
|
||||
useOverlays.setState({ attach: null });
|
||||
pending.resolve(ok([editor]));
|
||||
await request;
|
||||
expect(useOverlays.getState().attach).toBeNull();
|
||||
});
|
||||
|
||||
it("does not attach to an old project's process or retry installation after switching projects", async () => {
|
||||
await openAttachPopup("unity");
|
||||
render(<DebuggerOverlays />);
|
||||
act(() => useProject.setState({ project: { root: "/other" } as ProjectInfo }));
|
||||
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
|
||||
expect(mocks.start).not.toHaveBeenCalled();
|
||||
act(() =>
|
||||
useOverlays.setState({
|
||||
attach: { processes: [], error: "missing", mode: "unity", projectRoot: "/game", installTool: "unity-debug" },
|
||||
}),
|
||||
);
|
||||
await installAttachAdapter();
|
||||
expect(mocks.discover).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
@@ -80,14 +80,10 @@ import { expressionAt, valueHint } from "./editor/valueTooltip";
|
||||
import { mouseEvaluateTarget } from "./editor/quickEvaluate";
|
||||
import { showHint } from "@/editor/lsp/hint";
|
||||
import { pausedLineTargets, startInlineSmartStep } from "./editor/smartStep";
|
||||
import {
|
||||
openBreakpointsDialog,
|
||||
openConfigChooser,
|
||||
openEvaluateDialog,
|
||||
openSmartStepChooser,
|
||||
useOverlays,
|
||||
} from "./ui/popoverStore";
|
||||
import { openBreakpointsDialog, openConfigChooser, openEvaluateDialog, openSmartStepChooser } from "./ui/popoverStore";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { openAttachPopup } from "./attachPopup";
|
||||
export { openAttachPopup } from "./attachPopup";
|
||||
|
||||
function isRunConfig(arg: unknown): arg is RunConfig {
|
||||
return !!arg && typeof arg === "object" && "command" in arg && "args" in arg && "debugAdapter" in arg;
|
||||
@@ -180,22 +176,6 @@ async function smartStepInto() {
|
||||
if (!startInlineSmartStep(t.s.id, t.thread, targets)) openSmartStepChooser(t.s.id, t.thread, targets);
|
||||
}
|
||||
|
||||
/** Opens the Attach to Process popup and loads the process list. */
|
||||
export async function openAttachPopup() {
|
||||
if (!isTauri()) {
|
||||
notifications().notify({ group: "run", level: "warning", title: "Attaching needs the desktop app" });
|
||||
return;
|
||||
}
|
||||
useOverlays.setState({ attach: { processes: null, error: null } });
|
||||
try {
|
||||
const processes = await call(commands.debugAttachableProcesses());
|
||||
if (useOverlays.getState().attach) useOverlays.setState({ attach: { processes, error: null } });
|
||||
} catch (e) {
|
||||
if (useOverlays.getState().attach)
|
||||
useOverlays.setState({ attach: { processes: [], error: errorText(e) || "Cannot list processes" } });
|
||||
}
|
||||
}
|
||||
|
||||
function cursor(): { path: string; line: number; selection: string } | null {
|
||||
const ed = activeEditor();
|
||||
if (!ed) return null;
|
||||
@@ -891,6 +871,15 @@ export function registerDebugActions(): () => void {
|
||||
description: "Attach the debugger to a running Java, Node.js, Python, Go or native process",
|
||||
run: () => void openAttachPopup(),
|
||||
},
|
||||
{
|
||||
id: "debug.attachUnity",
|
||||
title: "Attach to Unity Process",
|
||||
category: "Run",
|
||||
icon: "debug",
|
||||
hidden: true,
|
||||
when: "projectOpen",
|
||||
run: ({ arg }) => openAttachPopup("unity", arg as RunConfig | undefined),
|
||||
},
|
||||
{
|
||||
id: "debug.debugInBrowser",
|
||||
title: "Debug in Browser",
|
||||
|
||||
@@ -7,6 +7,7 @@ import type { AttachKind, AttachableProcess, LaunchConfig } from "@/platform/ipc
|
||||
import { javaAttachConfig } from "./java";
|
||||
|
||||
export const KIND_LABELS: Record<AttachKind, string> = {
|
||||
unity: "Unity Editor",
|
||||
java: "Java (JDWP)",
|
||||
node: "Node.js",
|
||||
python: "Python (debugpy)",
|
||||
@@ -15,7 +16,7 @@ export const KIND_LABELS: Record<AttachKind, string> = {
|
||||
native: "Native (LLDB)",
|
||||
};
|
||||
|
||||
const KIND_ORDER: AttachKind[] = ["java", "node", "python", "dotnet", "go", "native"];
|
||||
const KIND_ORDER: AttachKind[] = ["unity", "java", "node", "python", "dotnet", "go", "native"];
|
||||
|
||||
export type AttachRow =
|
||||
| { kind: "group"; key: string; label: string; count: number }
|
||||
@@ -64,6 +65,14 @@ function base(p: AttachableProcess, cwd: string, extra: Record<string, unknown>)
|
||||
export async function attachConfig(p: AttachableProcess, root: string): Promise<LaunchConfig> {
|
||||
const skip = workflowSettings().debugger.skipLibraryCode;
|
||||
switch (p.kind) {
|
||||
case "unity":
|
||||
return {
|
||||
...base(p, root, {
|
||||
name: `Unity Editor (${p.pid})`,
|
||||
__exceptionOptions: [],
|
||||
}),
|
||||
adapter: "unity",
|
||||
};
|
||||
case "java":
|
||||
return javaAttachConfig(
|
||||
{ name: `${p.name} (${p.pid})`, module: "", hostName: p.host ?? "localhost", port: p.port! },
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
import { executeAction } from "@/platform/actions";
|
||||
import { call, commands, isTauri, type RunConfig } from "@/platform/ipc";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { notifications } from "@/workbench/contributions";
|
||||
import { missingAdapter } from "./missingAdapter";
|
||||
import { useOverlays } from "./ui/popoverStore";
|
||||
|
||||
/** Applies only the latest request of the open popup; results for a closed or refreshed one are dropped. */
|
||||
export async function openAttachPopup(mode: "all" | "unity" = "all", runConfig?: RunConfig) {
|
||||
if (!isTauri()) {
|
||||
notifications().notify({ group: "run", level: "warning", title: "Attaching needs the desktop app" });
|
||||
return;
|
||||
}
|
||||
const projectRoot = useProject.getState().project?.root ?? null;
|
||||
const pending = { processes: null, error: null, mode, projectRoot, runConfig };
|
||||
useOverlays.setState({ attach: pending });
|
||||
const current = () =>
|
||||
useOverlays.getState().attach === pending && (useProject.getState().project?.root ?? null) === projectRoot;
|
||||
try {
|
||||
const processes = await call(
|
||||
mode === "unity" ? commands.debugUnityProcesses() : commands.debugAttachableProcesses(),
|
||||
);
|
||||
if (current()) useOverlays.setState({ attach: { ...pending, processes } });
|
||||
} catch (e) {
|
||||
if (current())
|
||||
useOverlays.setState({
|
||||
attach: {
|
||||
...pending,
|
||||
processes: [],
|
||||
error: e instanceof Error ? e.message : String(e),
|
||||
installTool: mode === "unity" ? missingAdapter("unity", e)?.tool : undefined,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export async function installAttachAdapter() {
|
||||
const state = useOverlays.getState().attach;
|
||||
if (!state?.installTool) return;
|
||||
await executeAction("tools.install", state.installTool);
|
||||
if (useOverlays.getState().attach === state && useProject.getState().project?.root === state.projectRoot) {
|
||||
await openAttachPopup(state.mode, state.runConfig);
|
||||
}
|
||||
}
|
||||
@@ -145,6 +145,7 @@ export function activate(): () => void {
|
||||
useProject.subscribe((s, prev) => {
|
||||
const root = s.project?.root ?? null;
|
||||
if (root !== (prev.project?.root ?? null) || s.project?.trusted !== prev.project?.trusted) {
|
||||
useOverlays.setState({ attach: null });
|
||||
resetSessions();
|
||||
loadWatches(root);
|
||||
loadBreakpoints(root);
|
||||
|
||||
@@ -8,6 +8,7 @@ import { tx } from "@/platform/i18n";
|
||||
|
||||
/** Adapters the tools installer can provide (adapter id → tool name). */
|
||||
const INSTALLABLE: Record<string, { tool: string; title: string }> = {
|
||||
unity: { tool: "unity-debug", title: "Unity Debugger is not installed" },
|
||||
"kotlin-debug-adapter": { tool: "kotlin-debug-adapter", title: "The Kotlin debugger is not installed" },
|
||||
netcoredbg: { tool: "netcoredbg", title: "netcoredbg is not installed" },
|
||||
debugpy: { tool: "debugpy", title: "debugpy is not installed" },
|
||||
|
||||
@@ -33,6 +33,7 @@ import {
|
||||
type SpecialBreakpoint,
|
||||
} from "../breakpoints/special";
|
||||
import { attachConfig, attachDetail, attachRows, type AttachRow } from "../attach";
|
||||
import { openAttachPopup, installAttachAdapter } from "../attachPopup";
|
||||
import {
|
||||
exceptionGroups,
|
||||
filterHint,
|
||||
@@ -915,6 +916,7 @@ function AttachPopup() {
|
||||
const root = useProject((s) => s.project?.root ?? null);
|
||||
const [filter, setFilter] = useState("");
|
||||
const [active, setActive] = useState(0);
|
||||
const [installing, setInstalling] = useState(false);
|
||||
const rows = useMemo(() => attachRows(state?.processes ?? [], filter), [state?.processes, filter]);
|
||||
const firstItem = rows.findIndex((r) => r.kind === "process");
|
||||
const activeIndex = rows[active]?.kind === "process" ? active : firstItem;
|
||||
@@ -925,10 +927,11 @@ function AttachPopup() {
|
||||
useOverlays.setState({ attach: null });
|
||||
};
|
||||
const attach = async (p: AttachableProcess) => {
|
||||
if (state.projectRoot !== undefined && state.projectRoot !== root) return close();
|
||||
close();
|
||||
if (!root) return;
|
||||
try {
|
||||
await startSession(await attachConfig(p, root), { rerunnable: false });
|
||||
await startSession(await attachConfig(p, root), { rerunnable: false, runConfig: state.runConfig });
|
||||
} catch (e) {
|
||||
notifications().notify({
|
||||
group: "run",
|
||||
@@ -948,8 +951,44 @@ function AttachPopup() {
|
||||
}
|
||||
};
|
||||
return (
|
||||
<Dialog open onClose={close} title="Attach to Process" width={640} position="top" aria-label="Attach to process">
|
||||
<Dialog
|
||||
open
|
||||
onClose={close}
|
||||
title={state.mode === "unity" ? "Attach to Unity Process" : "Attach to Process"}
|
||||
width={640}
|
||||
position="top"
|
||||
aria-label={state.mode === "unity" ? "Attach to Unity Process" : "Attach to process"}
|
||||
buttons={[
|
||||
{
|
||||
label: "Refresh",
|
||||
role: "extra",
|
||||
disabled: state.processes === null || installing,
|
||||
onClick: () => {
|
||||
setActive(0);
|
||||
void openAttachPopup(state.mode, state.runConfig);
|
||||
},
|
||||
},
|
||||
{ label: "Cancel", role: "cancel", onClick: close },
|
||||
{
|
||||
label: "Attach",
|
||||
role: "default",
|
||||
disabled: rows[activeIndex]?.kind !== "process" || installing,
|
||||
onClick: () => {
|
||||
const row = rows[activeIndex];
|
||||
if (row?.kind === "process") void attach(row.process);
|
||||
},
|
||||
},
|
||||
]}
|
||||
>
|
||||
<div className={styles.evalBody}>
|
||||
{state.mode === "unity" && (
|
||||
<p>
|
||||
<T>
|
||||
Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process
|
||||
below. Stopping debugging disconnects without closing Unity.
|
||||
</T>
|
||||
</p>
|
||||
)}
|
||||
<Input
|
||||
value={filter}
|
||||
onChange={(e) => {
|
||||
@@ -975,7 +1014,20 @@ function AttachPopup() {
|
||||
<T>Loading processes…</T>
|
||||
</div>
|
||||
) : state.error ? (
|
||||
<div className={styles.empty}>{state.error}</div>
|
||||
<div className={styles.empty}>
|
||||
<div>{state.error}</div>
|
||||
{state.installTool && (
|
||||
<Button
|
||||
disabled={installing}
|
||||
onClick={() => {
|
||||
setInstalling(true);
|
||||
void installAttachAdapter().finally(() => setInstalling(false));
|
||||
}}
|
||||
>
|
||||
{installing ? "Installing…" : "Install Unity Debugger"}
|
||||
</Button>
|
||||
)}
|
||||
</div>
|
||||
) : (
|
||||
<List<AttachRow>
|
||||
items={rows}
|
||||
@@ -996,7 +1048,11 @@ function AttachPopup() {
|
||||
className={styles.attachList}
|
||||
empty={
|
||||
<div className={styles.empty}>
|
||||
{filter ? tx`No attachable processes match the filter.` : tx`No attachable processes.`}
|
||||
{filter
|
||||
? tx`No attachable processes match the filter.`
|
||||
: state.mode === "unity"
|
||||
? tx`No Unity Editor processes found. Open Unity Editor, then refresh.`
|
||||
: tx`No attachable processes.`}
|
||||
</div>
|
||||
}
|
||||
renderItem={(r) =>
|
||||
|
||||
@@ -15,7 +15,14 @@ interface OverlayState {
|
||||
breakpoints: { path?: string; id?: string } | null;
|
||||
chooser: { configs: RunConfig[] } | null;
|
||||
/** Attach to Process popup; `processes` is null while loading. */
|
||||
attach: { processes: AttachableProcess[] | null; error: string | null } | null;
|
||||
attach: {
|
||||
processes: AttachableProcess[] | null;
|
||||
error: string | null;
|
||||
mode?: "all" | "unity";
|
||||
projectRoot?: string | null;
|
||||
installTool?: string;
|
||||
runConfig?: RunConfig;
|
||||
} | null;
|
||||
/**
|
||||
* Smart Step Into: picked in the editor when `inline` is set (targets sorted
|
||||
* by position, `index` the selected one), else in the chooser dialog.
|
||||
|
||||
@@ -48,7 +48,7 @@ import { activate as analysis } from "./analysis";
|
||||
import { activate as services } from "./services";
|
||||
import { activate as github, activateSettingsPages as githubPages } from "./github";
|
||||
import { activate as httpClient } from "./http-client";
|
||||
import { activate as database } from "./database";
|
||||
import { activate as database, activateSettingsPages as databasePages } from "./database";
|
||||
import { activate as graphql } from "./graphql";
|
||||
import { activate as deployment, activateDeploymentWindow } from "./deployment";
|
||||
import { activate as agents, activateSettingsPages as agentsPages } from "./agents";
|
||||
@@ -188,6 +188,7 @@ export function activateSettingsWindowFeatures(parent: string): () => void {
|
||||
["vim", vimPages],
|
||||
["vcs", vcsPages],
|
||||
["github", githubPages],
|
||||
["database", databasePages],
|
||||
];
|
||||
return activateAll("settings pages", pages);
|
||||
}
|
||||
@@ -1,8 +1,8 @@
|
||||
import { afterEach, beforeEach, expect, it, vi } from "vitest";
|
||||
import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
|
||||
import { executeAction, executeActionFrom, getAction, registerAction } from "@/platform/actions";
|
||||
import { executeAction, executeActionFrom, getAction, isActionEnabled, registerAction } from "@/platform/actions";
|
||||
import { setContext } from "@/platform/context";
|
||||
import type { RunConfig } from "@/platform/ipc";
|
||||
import type { ProjectInfo, RunConfig } from "@/platform/ipc";
|
||||
import {
|
||||
registerMenuGroup,
|
||||
registerRunConfigType,
|
||||
@@ -10,6 +10,7 @@ import {
|
||||
type DebugRunSession,
|
||||
} from "@/workbench/contributions";
|
||||
import { useContextMenuStore } from "@/ui";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { applicationConfig } from "./application";
|
||||
import { activate } from "./index";
|
||||
import { RunWidget } from "./RunWidget";
|
||||
@@ -52,6 +53,7 @@ const debug = (c: RunConfig, startedAt = 2): DebugRunSession => ({
|
||||
});
|
||||
let dispose: () => void;
|
||||
beforeEach(() => {
|
||||
useProject.setState({ project: null });
|
||||
resetRuns();
|
||||
useRun.setState({ configs: [app, npm], selectedId: app.id, loaded: true });
|
||||
useDebugRunSessions.setState({ sessions: [] });
|
||||
@@ -61,9 +63,51 @@ beforeEach(() => {
|
||||
afterEach(() => {
|
||||
cleanup();
|
||||
dispose();
|
||||
useProject.setState({ project: null });
|
||||
useDebugRunSessions.setState({ sessions: [] });
|
||||
});
|
||||
|
||||
function openUnity() {
|
||||
useProject.setState({
|
||||
project: {
|
||||
root: "/game",
|
||||
name: "Game",
|
||||
trusted: true,
|
||||
isGit: false,
|
||||
settings: {} as ProjectInfo["settings"],
|
||||
unity: { editorVersion: "6000.0.1f1", projects: [], solutions: [] },
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
it("keeps other configurations available in a Unity project", () => {
|
||||
openUnity();
|
||||
useRun.setState({ configs: [app, npm], selectedId: app.id, loaded: true });
|
||||
render(<RunWidget />);
|
||||
expect(screen.getByRole("button", { name: `Run '${app.name}'` })).toBeEnabled();
|
||||
expect(isActionEnabled(getAction("run.run")!)).toBe(true);
|
||||
expect(isActionEnabled(getAction("run.chooseConfig")!)).toBe(true);
|
||||
});
|
||||
|
||||
it("attaches when the Unity configuration is debugged", async () => {
|
||||
openUnity();
|
||||
const unity = { ...config("unity-editor"), name: "Unity Editor", kind: "unity-editor", command: "" };
|
||||
useRun.setState({ configs: [unity, app], selectedId: unity.id, loaded: true });
|
||||
const attach = vi.fn();
|
||||
const unregister = registerAction({ id: "debug.attachUnity", title: "Attach", run: attach });
|
||||
try {
|
||||
render(<RunWidget />);
|
||||
expect(screen.getByRole("button", { name: `'${unity.name}' can only be debugged` })).toBeDisabled();
|
||||
await act(async () => {
|
||||
await executeAction("run.debug");
|
||||
});
|
||||
expect(attach).toHaveBeenCalledOnce();
|
||||
expect(useRun.getState().configs).toContain(app);
|
||||
} finally {
|
||||
unregister();
|
||||
}
|
||||
});
|
||||
|
||||
it("reruns and stops the selected configuration among several running sessions", () => {
|
||||
useRun.setState({ sessions: [run(app), run(npm, 3)] });
|
||||
render(<RunWidget />);
|
||||
|
||||
@@ -67,6 +67,32 @@ it("lists pinned configurations first, in pin order, and not again in their grou
|
||||
expect(names(buildRows(configs, "s", null, [], ["serve"]))).toEqual(["[Pinned]", "serve", "---", "edit"]);
|
||||
});
|
||||
|
||||
it("adds and selects a Unity attach configuration without hiding other configurations", async () => {
|
||||
useProject.setState({ project: { root: "/pinned", unity: {} } as never });
|
||||
await loadConfigs();
|
||||
expect(useRun.getState().configs.map((c) => c.id)).toEqual(["build", "serve", "App", "unity-editor"]);
|
||||
expect(useRun.getState().selectedId).toBe("unity-editor");
|
||||
await loadConfigs();
|
||||
expect(useRun.getState().configs.filter((c) => c.kind === "unity-editor")).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("keeps a configuration whose id collides with the Unity default", async () => {
|
||||
useProject.setState({ project: { root: "/pinned", unity: {} } as never });
|
||||
ipc.runConfigs.mockResolvedValue({ status: "ok", data: [config("unity-editor")] });
|
||||
await loadConfigs();
|
||||
expect(useRun.getState().configs.map((c) => c.id)).toEqual(["unity-editor", "unity-editor-attach"]);
|
||||
expect(useRun.getState().selectedId).toBe("unity-editor-attach");
|
||||
});
|
||||
|
||||
it("retains a saved Unity configuration and selected configuration", async () => {
|
||||
useProject.setState({ project: { root: "/pinned", unity: {} } as never });
|
||||
ipc.runConfigs.mockResolvedValue({ status: "ok", data: [...configs, config("my-unity", "unity-editor")] });
|
||||
useRun.setState({ selectedId: "serve" });
|
||||
await loadConfigs();
|
||||
expect(useRun.getState().configs.filter((c) => c.kind === "unity-editor")).toHaveLength(1);
|
||||
expect(useRun.getState().selectedId).toBe("serve");
|
||||
});
|
||||
|
||||
it("keeps pins per project across reloads", async () => {
|
||||
await loadConfigs();
|
||||
togglePinned("serve");
|
||||
|
||||
@@ -104,6 +104,7 @@ import { TEST_TREE_FOCUS, testTree } from "./testTree";
|
||||
import { startAgentRun, trimAgentArchive, type AgentRunRequest } from "./agentRuns";
|
||||
import { compoundTargets, selectedTarget } from "./sessionTargets";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { UNITY_CONFIG_KIND, showUnityAttach } from "./unity";
|
||||
|
||||
function trackFailedTestSelection(): () => void {
|
||||
let signature = "";
|
||||
@@ -171,6 +172,7 @@ async function debugConfig(config: RunConfig, chain: readonly string[] = [], sho
|
||||
}
|
||||
if (remoteDebugBlocked(config)) return;
|
||||
if (!(await prepareLaunch(config, chain, show))) return;
|
||||
if (config.kind === UNITY_CONFIG_KIND) return showUnityAttach(config);
|
||||
// Python on a Docker / Compose target: debugpy in the container, the debugger attaches.
|
||||
if (containerDebuggable(config) && getAction("debug.attach")) {
|
||||
await debugInContainer(config);
|
||||
@@ -488,6 +490,14 @@ export function activate(): () => void {
|
||||
when: "projectOpen",
|
||||
run: () => debugSelected(),
|
||||
},
|
||||
{
|
||||
id: "run.attachUnity",
|
||||
title: "Attach to Unity Process",
|
||||
category: "Run",
|
||||
icon: "debug",
|
||||
when: "projectOpen",
|
||||
run: () => showUnityAttach(),
|
||||
},
|
||||
{
|
||||
id: "run.runContext",
|
||||
title: "Run Context Configuration",
|
||||
|
||||
@@ -65,6 +65,7 @@ import { tomcatBrowserUrl } from "./tomcat";
|
||||
import { gradleBootLaunch, gradleDelegation, gradleTestLaunch } from "./gradleRun";
|
||||
import { openUrl } from "./navigate";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { UNITY_CONFIG_KIND } from "./unity";
|
||||
|
||||
/** The permanent "Current File" pseudo-configuration of the chooser (runs the active file's context). */
|
||||
export const CURRENT_FILE = "current-file";
|
||||
@@ -240,11 +241,29 @@ export async function loadConfigs(): Promise<void> {
|
||||
const temps = kept.length ? await call(commands.runApplySettings(kept)).catch(() => kept) : kept;
|
||||
if (useProject.getState().project?.root !== root) return;
|
||||
const configs = [...saved, ...temps];
|
||||
if (useProject.getState().project?.unity && !configs.some((config) => config.kind === UNITY_CONFIG_KIND)) {
|
||||
let id = "unity-editor";
|
||||
while (configs.some((config) => config.id === id)) id += "-attach";
|
||||
configs.push({
|
||||
id,
|
||||
name: "Unity Editor",
|
||||
kind: UNITY_CONFIG_KIND,
|
||||
command: "",
|
||||
args: [],
|
||||
cwd: null,
|
||||
env: {},
|
||||
detected: true,
|
||||
isTest: false,
|
||||
debugAdapter: null,
|
||||
});
|
||||
}
|
||||
const stored = useRun.getState().selectedId ?? readSelected(root);
|
||||
const selectedId =
|
||||
stored === CURRENT_FILE || configs.some((c) => c.id === stored)
|
||||
? stored
|
||||
: (defaultSelection(saved)?.id ?? CURRENT_FILE);
|
||||
: (configs.find((config) => config.kind === UNITY_CONFIG_KIND)?.id ??
|
||||
defaultSelection(saved)?.id ??
|
||||
CURRENT_FILE);
|
||||
useRun.setState({
|
||||
configs,
|
||||
temporary: temps.map((t) => t.id),
|
||||
|
||||
@@ -28,6 +28,7 @@ import { dotnetProjectType, dotnetTestType } from "./dotnetTypes";
|
||||
import { rakeType, rspecType, rubyScriptType } from "./rubyTypes";
|
||||
import { djangoTestType } from "./djangoTypes";
|
||||
import { phpunitType } from "./phpunitTypes";
|
||||
import { UNITY_CONFIG_KIND } from "./unity";
|
||||
|
||||
export const COMPOUND = "compound";
|
||||
|
||||
@@ -475,6 +476,14 @@ const pytest: RunConfigTypeContribution = {
|
||||
};
|
||||
|
||||
export const BUILTIN_TYPES: readonly RunConfigTypeContribution[] = [
|
||||
{
|
||||
id: UNITY_CONFIG_KIND,
|
||||
label: "Unity Editor",
|
||||
icon: "attach-to-process",
|
||||
debugOnly: true,
|
||||
fields: [],
|
||||
commandLine: () => null,
|
||||
},
|
||||
shell,
|
||||
program,
|
||||
npm,
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
import { executeAction, getAction } from "@/platform/actions";
|
||||
import type { RunConfig } from "@/platform/ipc";
|
||||
import { notifications } from "@/workbench/contributions";
|
||||
|
||||
export const UNITY_CONFIG_KIND = "unity-editor";
|
||||
|
||||
export async function showUnityAttach(config?: RunConfig): Promise<void> {
|
||||
if (!getAction("debug.attachUnity")) {
|
||||
notifications().notify({ group: "run", level: "warning", title: "Debugger is not available" });
|
||||
return;
|
||||
}
|
||||
await executeAction("debug.attachUnity", config);
|
||||
}
|
||||
@@ -156,8 +156,10 @@ describe("appearance & behavior settings", () => {
|
||||
expect(validateNotifications({ groups: { vcs: { display: "weird", log: false } }, sound: 1 })).toEqual({
|
||||
balloons: true,
|
||||
sound: false,
|
||||
systemNotifications: true,
|
||||
groups: { vcs: { display: "balloon", log: false } },
|
||||
});
|
||||
expect(validateNotifications({ systemNotifications: false }).systemNotifications).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
@@ -152,10 +152,11 @@ function PageHost({
|
||||
const spec = page ? builtinSpec(page.id) : undefined;
|
||||
const projectScope = !!(spec?.projectScope ?? page?.projectScope) && hasProject && !newProjects;
|
||||
const scopeKey = spec?.scopeGroup ?? pageId;
|
||||
const chosen = useSettingsDialog((s) => s.scopes[scopeKey]) ?? spec?.defaultScope;
|
||||
const defaultScope = spec?.defaultScope ?? page?.defaultScope;
|
||||
const chosen = useSettingsDialog((s) => s.scopes[scopeKey]) ?? defaultScope;
|
||||
const scope: Scope = projectScope && chosen === "project" ? "project" : "global";
|
||||
// Where a project value is the norm, say what the global one is for.
|
||||
const globalNote = newProjects || (projectScope && scope === "global" && spec?.defaultScope === "project");
|
||||
const globalNote = newProjects || (projectScope && scope === "global" && defaultScope === "project");
|
||||
const ctx = useMemo(() => ({ pageId, scope }), [pageId, scope]);
|
||||
const form = useSettingsFormFor(pageId, scope);
|
||||
const focus = useSettingsDialog((s) => s.focus);
|
||||
|
||||
@@ -108,6 +108,8 @@ export interface NotificationGroupValid {
|
||||
export interface NotificationsValid {
|
||||
balloons: boolean;
|
||||
sound: boolean;
|
||||
/** Mirror balloon notifications to the OS when no OpenIDEA window is focused. */
|
||||
systemNotifications: boolean;
|
||||
groups: Record<string, NotificationGroupValid>;
|
||||
}
|
||||
|
||||
@@ -160,7 +162,12 @@ export const DEFAULT_GENERAL_EXTRAS: GeneralExtras = {
|
||||
dateFormat: { overrideSystem: false, pattern: "dd.MM.yyyy", use24Hour: true, pretty: true },
|
||||
};
|
||||
|
||||
export const DEFAULT_NOTIFICATIONS: NotificationsValid = { balloons: true, sound: false, groups: {} };
|
||||
export const DEFAULT_NOTIFICATIONS: NotificationsValid = {
|
||||
balloons: true,
|
||||
sound: false,
|
||||
systemNotifications: true,
|
||||
groups: {},
|
||||
};
|
||||
|
||||
type Obj = Record<string, unknown>;
|
||||
const obj = (v: unknown): Obj => (v && typeof v === "object" && !Array.isArray(v) ? (v as Obj) : {});
|
||||
@@ -263,6 +270,7 @@ export function validateNotifications(raw: unknown): NotificationsValid {
|
||||
return {
|
||||
balloons: bool(n.balloons, DEFAULT_NOTIFICATIONS.balloons),
|
||||
sound: bool(n.sound, DEFAULT_NOTIFICATIONS.sound),
|
||||
systemNotifications: bool(n.systemNotifications, DEFAULT_NOTIFICATIONS.systemNotifications),
|
||||
groups,
|
||||
};
|
||||
}
|
||||
@@ -63,6 +63,8 @@ export interface ValidSettings extends WorkflowSettings {
|
||||
plugins: Record<string, Record<string, unknown>>;
|
||||
scopes: NamedScope[];
|
||||
fileColors: FileColorSettings;
|
||||
/** Database › Query Execution. */
|
||||
database: { inEditorResults: boolean; resolutionScopes: Array<{ path: string; dataSource: string; schema: string }> };
|
||||
general: {
|
||||
reopenLastProject: boolean;
|
||||
confirmExit: boolean;
|
||||
@@ -165,6 +167,7 @@ export const DEFAULT_SETTINGS: ValidSettings = {
|
||||
plugins: {},
|
||||
scopes: [],
|
||||
fileColors: DEFAULT_FILE_COLORS,
|
||||
database: { inEditorResults: false, resolutionScopes: [] },
|
||||
general: {
|
||||
reopenLastProject: true,
|
||||
confirmExit: true,
|
||||
@@ -340,6 +343,17 @@ export function validateSettings(raw: Settings | unknown): ValidSettings {
|
||||
plugins: Object.fromEntries(Object.entries(obj(root.plugins)).map(([id, values]) => [id, obj(values)])),
|
||||
scopes: validateScopes(root.scopes),
|
||||
fileColors: validateFileColors(root.fileColors),
|
||||
database: {
|
||||
inEditorResults: bool(obj(root.database).inEditorResults, d.database.inEditorResults),
|
||||
resolutionScopes: (Array.isArray(obj(root.database).resolutionScopes)
|
||||
? (obj(root.database).resolutionScopes as unknown[])
|
||||
: []
|
||||
).map((r) => ({
|
||||
path: str(obj(r).path, ""),
|
||||
dataSource: str(obj(r).dataSource, ""),
|
||||
schema: str(obj(r).schema, ""),
|
||||
})),
|
||||
},
|
||||
general: {
|
||||
...validateGeneralExtras(g),
|
||||
reopenLastProject: bool(g.reopenLastProject, d.general.reopenLastProject),
|
||||
|
||||
@@ -1086,12 +1086,17 @@ export const BEHAVIOR_PAGES: PageSpec[] = [
|
||||
title: "Notifications",
|
||||
group: APPEARANCE_GROUP,
|
||||
order: 2,
|
||||
keywords: ["balloon", "popup", "sound", "alerts"],
|
||||
keywords: ["balloon", "popup", "sound", "alerts", "system", "os"],
|
||||
sections: [
|
||||
{
|
||||
options: [
|
||||
{ kind: "toggle", key: "notifications.balloons", label: "Display balloon notifications" },
|
||||
{ kind: "toggle", key: "notifications.sound", label: "Play sound" },
|
||||
{
|
||||
kind: "toggle",
|
||||
key: "notifications.systemNotifications",
|
||||
label: "Enable system notifications",
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
|
||||
@@ -1,4 +1,13 @@
|
||||
{
|
||||
"Unity Editor": "Unity Editor",
|
||||
"Attach to Unity Process": "Attach to Unity Process",
|
||||
"Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process below. Stopping debugging disconnects without closing Unity.": "Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process below. Stopping debugging disconnects without closing Unity.",
|
||||
"No Unity Editor processes found. Open Unity Editor, then refresh.": "No Unity Editor processes found. Open Unity Editor, then refresh.",
|
||||
"Install Unity Debugger": "Install Unity Debugger",
|
||||
"Unity Debugger is not installed": "Unity Debugger is not installed",
|
||||
"Debugger is not available": "Debugger is not available",
|
||||
"Attach": "Attach",
|
||||
"Installing…": "Installing…",
|
||||
"moved from {oldPath}": "moved from {oldPath}",
|
||||
"Symbolic link": "Symbolic link",
|
||||
"Copy as TSV": "Copy as TSV",
|
||||
@@ -1959,5 +1968,14 @@
|
||||
"Non-Project Files": "Non-Project Files",
|
||||
"file:src//*.ts && !file:*.test.ts — paths are relative to the project; // is any folders, * any characters. file[module]:pattern limits a pattern to a module.": "file:src//*.ts && !file:*.test.ts — paths are relative to the project; // is any folders, * any characters. file[module]:pattern limits a pattern to a module.",
|
||||
"Clear File Color": "Clear File Color",
|
||||
"Edit File Colors…": "Edit File Colors…"
|
||||
"Edit File Colors…": "Edit File Colors…",
|
||||
"Enable system notifications": "Enable system notifications",
|
||||
"In-Editor Results": "In-Editor Results",
|
||||
"Show query results in the editor, under the statements that produced them": "Show query results in the editor, under the statements that produced them",
|
||||
"SQL Resolution Scopes": "SQL Resolution Scopes",
|
||||
"SQL in these folders and files resolves against the data source: completion, inspections and navigation use its tables, and query consoles run on it unless another data source is picked in their toolbar.": "SQL in these folders and files resolves against the data source: completion, inspections and navigation use its tables, and query consoles run on it unless another data source is picked in their toolbar.",
|
||||
"Project data source": "Project data source",
|
||||
"Project schema": "Project schema",
|
||||
"Add Folder or File": "Add Folder or File",
|
||||
"Paths are relative to the project root. The deepest folder or file that contains a file applies to it.": "Paths are relative to the project root. The deepest folder or file that contains a file applies to it."
|
||||
}
|
||||
@@ -1,4 +1,12 @@
|
||||
{
|
||||
"Unity Editor": "Unity 编辑器",
|
||||
"Attach to Unity Process": "附加到 Unity 进程",
|
||||
"Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process below. Stopping debugging disconnects without closing Unity.": "在 Unity 编辑器中打开项目,启用 Editor Attaching 并切换到 Debug Mode,然后在下方选择对应进程。停止调试会断开连接,Unity 编辑器会继续运行。",
|
||||
"No Unity Editor processes found. Open Unity Editor, then refresh.": "未找到 Unity 编辑器进程。打开 Unity 编辑器后刷新。",
|
||||
"Install Unity Debugger": "安装 Unity 调试器",
|
||||
"Unity Debugger is not installed": "尚未安装 Unity 调试器",
|
||||
"Attach": "附加",
|
||||
"Installing…": "正在安装…",
|
||||
"Symbolic link": "符号链接",
|
||||
"Copy as TSV": "复制为 TSV",
|
||||
"Copy as CSV": "复制为 CSV",
|
||||
@@ -8352,5 +8360,14 @@
|
||||
"Non-Project Files": "非项目文件",
|
||||
"file:src//*.ts && !file:*.test.ts — paths are relative to the project; // is any folders, * any characters. file[module]:pattern limits a pattern to a module.": "file:src//*.ts && !file:*.test.ts —— 路径相对于项目;// 表示任意层文件夹,* 表示任意字符。file[module]:pattern 将模式限定在某个模块内。",
|
||||
"Clear File Color": "清除文件颜色",
|
||||
"Edit File Colors…": "编辑文件颜色…"
|
||||
"Edit File Colors…": "编辑文件颜色…",
|
||||
"Enable system notifications": "启用系统通知",
|
||||
"In-Editor Results": "编辑器内结果",
|
||||
"Show query results in the editor, under the statements that produced them": "在编辑器中、产生结果的语句下方显示查询结果",
|
||||
"SQL Resolution Scopes": "SQL 解析作用域",
|
||||
"SQL in these folders and files resolves against the data source: completion, inspections and navigation use its tables, and query consoles run on it unless another data source is picked in their toolbar.": "这些文件夹和文件中的 SQL 按所选数据源解析:补全、检查和导航使用它的表;查询控制台也在它上面执行,除非在控制台工具栏中另选了数据源。",
|
||||
"Project data source": "项目数据源",
|
||||
"Project schema": "项目架构",
|
||||
"Add Folder or File": "添加文件夹或文件",
|
||||
"Paths are relative to the project root. The deepest folder or file that contains a file applies to it.": "路径相对于项目根目录。对某个文件生效的是包含它的最深一级文件夹或该文件本身。"
|
||||
}
|
||||
@@ -383,6 +383,7 @@ const ICONS = {
|
||||
"db-sequence": "openidea/database/sequence",
|
||||
"db-plan": "openidea/database/plan",
|
||||
"db-chart": "openidea/database/chart",
|
||||
"db-in-editor-results": "openidea/database/inEditorResults",
|
||||
"db-sort": "openidea/database/sort",
|
||||
"db-folder": "openidea/database/folder",
|
||||
"db-add": "openidea/database/addDropdown",
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
<!-- OpenIDEA: in-editor results (text lines over a result grid) -->
|
||||
<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
|
||||
<path d="M2.5 2.5H10.5M2.5 5H7.5" stroke="#6C707E" stroke-linecap="round"/><rect x="2.5" y="7.5" width="11" height="6" rx="1" stroke="#6C707E"/><path d="M2.5 10.5H13.5M6.5 7.5V13.5" stroke="#6C707E"/>
|
||||
</svg>
|
||||
|
Після Ширина: | Висота: | Розмір: 373 B |
@@ -758,6 +758,8 @@ export interface NotificationService {
|
||||
* silence what the IDE reports on its own, not the answer to a request.
|
||||
*/
|
||||
userInitiated?: boolean;
|
||||
/** Skip the chime even when "Play sound" is on (e.g. native OS sound already played). */
|
||||
silent?: boolean;
|
||||
}): void;
|
||||
/** Hides the balloon of the notification with `key` (it stays in the log), e.g. once its cause is gone. */
|
||||
expire?(key: string): void;
|
||||
@@ -1089,6 +1091,8 @@ export interface SettingsPageContribution {
|
||||
component?: ComponentType;
|
||||
/** The page edits settings that a project can override (Global / This project switch). */
|
||||
projectScope?: boolean;
|
||||
/** The scope the switch starts on (default: global). */
|
||||
defaultScope?: "global" | "project";
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
/** Notification center: balloons + history, backing `NotificationService`. */
|
||||
import type { ReactNode } from "react";
|
||||
import { create } from "zustand";
|
||||
import { call, commands, onIdeEvent } from "@/platform/ipc";
|
||||
import { call, commands, isTauri, onIdeEvent } from "@/platform/ipc";
|
||||
import { buildToolRecovery } from "@/platform/buildToolRecovery";
|
||||
import { txTemplate } from "@/platform/i18n";
|
||||
import { useProject } from "@/platform/project";
|
||||
@@ -154,7 +154,16 @@ export function notify(n: Parameters<NotificationService["notify"]>[0]): number
|
||||
const rest = n.key ? s.items.filter((x) => x.key !== n.key) : s.items;
|
||||
return { items: [item, ...rest].slice(0, MAX_HISTORY) };
|
||||
});
|
||||
if (balloon && prefs.sound) playSound();
|
||||
// OS toast owns the chime when system notifications are on and the app is backgrounded.
|
||||
const systemOn = useProject.getState().settings?.notifications?.systemNotifications !== false;
|
||||
const backgrounded = typeof document !== "undefined" && !document.hasFocus();
|
||||
if (balloon && prefs.sound && !n.silent && !(systemOn && backgrounded)) playSound();
|
||||
if (balloon && isTauri()) {
|
||||
// In the UI language, as the balloon shows it; a plugin's own text stays as written.
|
||||
const shown = (text: string) => (n.verbatim ? text : txTemplate(text));
|
||||
const plain = typeof n.body === "string" ? shown(n.body) : "";
|
||||
void call(commands.showSystemNotification(shown(n.title), plain)).catch(() => {});
|
||||
}
|
||||
return id;
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Заблокувати користувача