Skip to content

armgit / Wake

Public Imported from GitHub
0

All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.

Rust

Release v0.2.8: add location controls

Corey Chiu21ea0ef76814
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6e574e5..158b0cd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
# Changelog
+## [0.2.8] — 2026-08-25
+
+- New: every Session location has its own on/off switch — disabled paths stop scanning and disappear from browse/search results without losing their configuration
+- Update: Remove is reserved for custom locations; built-in locations can be disabled and re-enabled in place
+- Fix: disabled locations remain part of duplicate-path validation, and Restore defaults updates immediately as switches change
+
## [0.2.7] — 2026-08-25
- New: experimental Windows support — browse, search and resume sessions on Windows desktops; build from source with `scripts/make-windows.ps1`, or grab a prebuilt zip from the manual "Windows artifact" workflow
diff --git a/Cargo.lock b/Cargo.lock
index b26e658..fb592d9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6804,7 +6804,7 @@ dependencies = [
[[package]]
name = "wake"
-version = "0.2.7"
+version = "0.2.8"
dependencies = [
"anyhow",
"chrono",
@@ -6820,7 +6820,7 @@ dependencies = [
[[package]]
name = "wake-core"
-version = "0.2.7"
+version = "0.2.8"
dependencies = [
"anyhow",
"chrono",
diff --git a/Cargo.toml b/Cargo.toml
index 0920999..064a392 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,7 +3,7 @@ resolver = "2"
members = ["crates/wake-core", "crates/wake"]
[workspace.package]
-version = "0.2.7"
+version = "0.2.8"
edition = "2021"
license = "MIT"
diff --git a/DESIGN.md b/DESIGN.md
index 8b32498..1c7e52f 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -133,7 +133,7 @@ macOS 不设置横跨三栏的自定义 header。系统交通灯保留在侧栏
- 线条图标比实心品牌图视觉轻,同档里给小一号:分组项 Lucide 14 / 品牌图 18,主导航 Lucide 15。
- 行内容 = 行首元素 + 标题 + 计数;计数一律 Label 档 muted。
- 组头 "Agents"/"Projects" 用 Body 档常规字重 + muted 色(与主导航同字号同字重,仅靠颜色和"无行首图标"区分——加粗会让组头压过它统辖的行),带 13px chevron 可折叠。
-- 底部工具条常驻,顶部 hairline 分隔,按钮靠右排列(次要操作区:透明底、hover 才出色,不与导航行选中态抢注意力)——左为 "Session locations"(硬盘图标,开面板列出每家 agent 的数据路径、会话数,点击行在 Finder(平台文件管理器,文案走 SHOW_IN_FM)打开;行按 AgentId 声明序稳定成组(自定义根紧随该家默认根之后);**行点击即编辑**,预设与自定义同权、均可改可删(2026-08-24 定稿)。添加/编辑共用一个表单弹窗(480px,agent 下拉 + 路径输入框可手输 ~ 展开 + 目录选择钮,Add|Save / Cancel)**压栈**在面板之上,esc/取消原生弹回面板;**纯路径管理无内容校验**(同日定稿),保存后先出通知、待补扫终态(增量,常亚秒)再重开面板——此刻计数才是真值,立即重开会让新根恒显 0(2026-08-24 Codex review)。行尾仅计数 badge(悬停工具图标试过、否决,同日——Show in Finder 与 Remove 收进编辑表单的动作行——破坏性靠左惯例:Remove(danger 红字 ghost)压内容左缘,Show in Finder 靠右);底部 hairline 下左 "Add location" 右 "Restore defaults"(仅存在偏离时出现,双清自定义与被移除预设;hover 胶囊只包按钮本体——整行 hover 否决,同日)),右为 refresh。
+- 底部工具条常驻,顶部 hairline 分隔,按钮靠右排列(次要操作区:透明底、hover 才出色,不与导航行选中态抢注意力)——左为 "Session locations"(硬盘图标,开面板列出每家 agent 的数据路径、会话数与**逐路径开关**;关闭后保留配置,停止扫描/监听并从会话与搜索结果排除,重新开启即增量扫回。行按 AgentId 声明序稳定成组(自定义根紧随该家默认根之后),**行点击即编辑**;只有自定义 location 可真正 Remove,内置 location 只可启停或改指其他路径。添加/编辑共用一个表单弹窗(480px,agent 下拉 + 路径输入框可手输 ~ 展开 + 目录选择钮,Add|Save / Cancel)**压栈**在面板之上,esc/取消原生弹回面板;**纯路径管理无内容校验**(2026-08-24 定稿),保存后先出通知、待补扫终态(增量,常亚秒)再重开面板——此刻计数才是真值。启用行尾显示计数 badge,停用行显示 Disabled,最右为系统式小开关;Show in Finder 与自定义 Remove 收进编辑表单动作行。底部 hairline 下左 "Add location" 右 "Restore defaults"(仅存在偏离时出现,清空自定义、被移除预设与停用状态;hover 胶囊只包按钮本体)),右为 refresh。
- 工具条内的**状态行"常态沉默"**:仅刷新中或监听不可用时出现在按钮行上方;文案须可 truncate,窄侧栏放不下长句(故为 "Live updates off" 而非带操作建议的整句)。
- 不把项目包装成卡片,不堆叠分支、时间或重复图标。项目行不加彩色标识——同一图标重复十几次不传递信息。
diff --git a/crates/wake-core/src/adapters/codex.rs b/crates/wake-core/src/adapters/codex.rs
index e7b9703..6ef09cc 100644
--- a/crates/wake-core/src/adapters/codex.rs
+++ b/crates/wake-core/src/adapters/codex.rs
@@ -14,6 +14,8 @@ pub struct CodexAdapter {
sessions_dir: PathBuf,
archived_dir: PathBuf,
state_db: PathBuf,
+ scan_sessions: bool,
+ scan_archived: bool,
}
impl CodexAdapter {
@@ -28,6 +30,8 @@ impl CodexAdapter {
sessions_dir: root.join("sessions"),
archived_dir: root.join("archived_sessions"),
state_db: root.join("state_5.sqlite"),
+ scan_sessions: true,
+ scan_archived: true,
}
}
}
@@ -67,9 +71,7 @@ pub(crate) fn normalize_custom_root(dir: PathBuf) -> PathBuf {
let sibling = match name {
Some("sessions") => parent.join("archived_sessions").is_dir(),
Some("archived_sessions") => parent.join("sessions").is_dir(),
- _ => {
- parent.join("sessions").is_dir() || parent.join("archived_sessions").is_dir()
- }
+ _ => parent.join("sessions").is_dir() || parent.join("archived_sessions").is_dir(),
};
if parent.join("state_5.sqlite").is_file() || sibling {
return parent.to_path_buf();
@@ -345,7 +347,10 @@ fn parse_rollout(path: &Path) -> Result<CodexParse> {
}
}
"function_call_output" | "custom_tool_call_output" => {
- let call_id = payload.get("call_id").and_then(|v| v.as_str()).unwrap_or("");
+ let call_id = payload
+ .get("call_id")
+ .and_then(|v| v.as_str())
+ .unwrap_or("");
if let Some(&(mi, ti)) = tool_index.get(call_id) {
let out_text = match payload.get("output") {
Some(Value::String(s)) => s.clone(),
@@ -353,10 +358,13 @@ fn parse_rollout(path: &Path) -> Result<CodexParse> {
.get("content")
.and_then(|v| v.as_str())
.map(String::from)
- .unwrap_or_else(|| serde_json::to_string(o).unwrap_or_default()),
+ .unwrap_or_else(|| {
+ serde_json::to_string(o).unwrap_or_default()
+ }),
_ => String::new(),
};
- messages[mi].tool_calls[ti].output = Some(clip(&out_text, MAX_TOOL_IO).0);
+ messages[mi].tool_calls[ti].output =
+ Some(clip(&out_text, MAX_TOOL_IO).0);
}
}
_ => {}
@@ -385,8 +393,12 @@ fn parse_rollout(path: &Path) -> Result<CodexParse> {
"agent_message" => {
if let Some(m) = payload.get("message").and_then(|v| v.as_str()) {
if !m.trim().is_empty() {
- event_fallback
- .push(mk_msg(Role::Assistant, MessageKind::Text, m.trim(), ts));
+ event_fallback.push(mk_msg(
+ Role::Assistant,
+ MessageKind::Text,
+ m.trim(),
+ ts,
+ ));
}
}
}
@@ -394,7 +406,12 @@ fn parse_rollout(path: &Path) -> Result<CodexParse> {
}
}
"compacted" => {
- messages.push(mk_msg(Role::System, MessageKind::CompactSummary, "── Context compacted ──", ts));
+ messages.push(mk_msg(
+ Role::System,
+ MessageKind::CompactSummary,
+ "── Context compacted ──",
+ ts,
+ ));
}
"world_state" => {}
_ => unknown_lines += 1,
@@ -402,7 +419,9 @@ fn parse_rollout(path: &Path) -> Result<CodexParse> {
}
// response_item 完全缺席的会话退回 event_msg 流
- let has_real = messages.iter().any(|m| m.kind == MessageKind::Text && !m.text.is_empty());
+ let has_real = messages
+ .iter()
+ .any(|m| m.kind == MessageKind::Text && !m.text.is_empty());
let mut final_messages = if has_real {
messages
} else if !event_fallback.is_empty() {
@@ -462,8 +481,16 @@ fn build_meta(r: &SessionFileRef, p: &CodexParse, archived_dir: &Path) -> Sessio
project_path: p.cwd.clone(),
project_name,
file_path: r.file_path.clone(),
- created_at: if p.created_at > 0 { p.created_at } else { r.mtime_ms },
- updated_at: if p.updated_at > 0 { p.updated_at } else { r.mtime_ms },
+ created_at: if p.created_at > 0 {
+ p.created_at
+ } else {
+ r.mtime_ms
+ },
+ updated_at: if p.updated_at > 0 {
+ p.updated_at
+ } else {
+ r.mtime_ms
+ },
message_count: p
.messages
.iter()
@@ -472,8 +499,14 @@ fn build_meta(r: &SessionFileRef, p: &CodexParse, archived_dir: &Path) -> Sessio
size_bytes: r.size,
git_branch: p.git_branch.clone(),
model: p.model.clone(),
- tokens_used: if p.tokens_used > 0 { Some(p.tokens_used) } else { None },
- archived: r.file_path.starts_with(&archived_dir.to_string_lossy().to_string()),
+ tokens_used: if p.tokens_used > 0 {
+ Some(p.tokens_used)
+ } else {
+ None
+ },
+ archived: r
+ .file_path
+ .starts_with(&archived_dir.to_string_lossy().to_string()),
source: p.source.clone(),
favorite: false,
pinned: false,
@@ -486,8 +519,18 @@ impl AgentAdapter for CodexAdapter {
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
- let mut refs = list_jsonl_refs(&self.sessions_dir, AgentId::Codex, rollout_native_id);
- refs.extend(list_jsonl_refs(&self.archived_dir, AgentId::Codex, rollout_native_id));
+ let mut refs = if self.scan_sessions {
+ list_jsonl_refs(&self.sessions_dir, AgentId::Codex, rollout_native_id)
+ } else {
+ Vec::new()
+ };
+ if self.scan_archived {
+ refs.extend(list_jsonl_refs(
+ &self.archived_dir,
+ AgentId::Codex,
+ rollout_native_id,
+ ));
+ }
Ok(refs)
}
@@ -612,10 +655,29 @@ impl AgentAdapter for CodexAdapter {
sessions_dir,
archived_dir,
state_db: dir.join("state_5.sqlite"),
+ scan_sessions: true,
+ scan_archived: true,
})
}
fn data_roots(&self) -> Vec<PathBuf> {
- vec![self.sessions_dir.clone(), self.archived_dir.clone()]
+ let mut roots = Vec::with_capacity(2);
+ if self.scan_sessions {
+ roots.push(self.sessions_dir.clone());
+ }
+ if self.scan_archived {
+ roots.push(self.archived_dir.clone());
+ }
+ roots
+ }
+
+ fn excluding_data_roots(&self, roots: &[PathBuf]) -> Option<Box<dyn AgentAdapter>> {
+ Some(Box::new(Self {
+ sessions_dir: self.sessions_dir.clone(),
+ archived_dir: self.archived_dir.clone(),
+ state_db: self.state_db.clone(),
+ scan_sessions: self.scan_sessions && !roots.contains(&self.sessions_dir),
+ scan_archived: self.scan_archived && !roots.contains(&self.archived_dir),
+ }))
}
}
diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rs
index d5eaed3..ac2176b 100644
--- a/crates/wake-core/src/adapters/mod.rs
+++ b/crates/wake-core/src/adapters/mod.rs
@@ -39,7 +39,10 @@ pub trait AgentAdapter: Send + Sync {
parse_utils::default_file_ref(self.agent(), path)
}
/// 快路径:不解析文件直接给出 meta(Codex 走 state DB)。None = 无快路径
- fn quick_meta(&self, _refs: &[SessionFileRef]) -> Option<std::collections::HashMap<String, SessionMeta>> {
+ fn quick_meta(
+ &self,
+ _refs: &[SessionFileRef],
+ ) -> Option<std::collections::HashMap<String, SessionMeta>> {
None
}
/// quick 与 parsed 的合并策略:默认 parsed 为准、quick 补缺。
@@ -61,7 +64,11 @@ pub trait AgentAdapter: Send + Sync {
/// 详情解析
fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript>;
/// 加载 sidechain 消息(仅 Claude/Cursor subagents)
- fn load_sidechain(&self, _r: &SessionFileRef, _sidechain_id: &str) -> Result<Vec<TranscriptMessage>> {
+ fn load_sidechain(
+ &self,
+ _r: &SessionFileRef,
+ _sidechain_id: &str,
+ ) -> Result<Vec<TranscriptMessage>> {
Ok(Vec::new())
}
/// 会话在磁盘上的全部归属路径(删除时一并 trash)。默认仅主文件;
@@ -81,7 +88,10 @@ pub trait AgentAdapter: Send + Sync {
/// 只有当监听范围确实不同于数据根时才覆写——否则一次根路径搬迁
/// (如 CODEX_HOME / XDG_DATA_HOME)就要在两处各改一遍,漏一处则静默失去实时更新
fn watch_paths(&self) -> Vec<std::path::PathBuf> {
- self.data_roots().into_iter().filter(|p| p.is_dir()).collect()
+ self.data_roots()
+ .into_iter()
+ .filter(|p| p.is_dir())
+ .collect()
}
/// 以自定义数据根构造本家的第二实例("Session locations" 的 Add location)。
/// `dir` 是用户在系统目录选择器里选中的目录;各家把它整形成自己默认根的形态
@@ -96,12 +106,10 @@ pub trait AgentAdapter: Send + Sync {
fn supports_individual_root_removal(&self) -> bool {
false
}
- /// 返回排除指定默认根后的同类 adapter。只在上一能力为 true 时调用;None
- /// 表示不支持按根裁剪。
- fn excluding_data_roots(
- &self,
- _roots: &[std::path::PathBuf],
- ) -> Option<Box<dyn AgentAdapter>> {
+ /// 返回排除指定数据根后的同类 adapter。默认 location 的 Remove 只在上一
+ /// 能力为 true 时调用;逐行启停也用它过滤多根 adapter,但不改变 Remove
+ /// 的产品语义。None 表示不支持局部裁剪。
+ fn excluding_data_roots(&self, _roots: &[std::path::PathBuf]) -> Option<Box<dyn AgentAdapter>> {
None
}
}
@@ -166,7 +174,6 @@ pub fn create_adapters() -> Vec<Box<dyn AgentAdapter>> {
]
}
-
/// 用户 location 配置下的完整 roster:默认实例在前(被用户移除的家除外),
/// 自定义实例按存储顺序追加在后。顺序是契约的一部分——"按 agent 找第一个"
/// 的兜底路径(watcher file_ref、adapter_ix_for 的 fallback)落在该家现存的
@@ -218,13 +225,72 @@ fn create_adapters_with_root_overrides(
v
}
+/// 管理界面中的一条真实数据根。`locations` 保留停用项;扫描与监听只消费
+/// `AdapterRoster::active`,两者由同一批 adapter 实例派生,避免环境变量或
+/// 文件系统探测在二次构造时产生不同快照。
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AdapterLocation {
+ pub agent: AgentId,
+ pub path: std::path::PathBuf,
+ pub enabled: bool,
+ /// 默认 location 的编辑表单是否允许只移除这一根(目前仅 OpenCode)。
+ pub individually_removable: bool,
+}
+
+pub struct AdapterRoster {
+ pub active: Vec<Box<dyn AgentAdapter>>,
+ pub locations: Vec<AdapterLocation>,
+}
+
+/// 按索引库配置同时构造“全部 location 快照”和“仅启用的扫描 roster”。停用
+/// 记录按 (agent, 真实数据根) 精确匹配,因此同一 Agent 的多个 location 可独立
+/// 控制;单根 adapter 全关后直接移出 active,多根 adapter 走局部裁剪。
+pub fn create_adapter_roster_for(store: &crate::db::Store) -> AdapterRoster {
+ let (customs, removed, removed_roots) = store.location_overrides();
+ let configured = create_adapters_with_root_overrides(&customs, &removed, &removed_roots);
+ let disabled: std::collections::HashSet<(AgentId, std::path::PathBuf)> =
+ store.disabled_locations().into_iter().collect();
+
+ let mut locations = Vec::new();
+ let mut active = Vec::new();
+ for adapter in configured {
+ let agent = adapter.agent();
+ let individually_removable = adapter.supports_individual_root_removal();
+ let roots = adapter.data_roots();
+ let excluded: Vec<std::path::PathBuf> = roots
+ .iter()
+ .filter(|root| disabled.contains(&(agent, (*root).clone())))
+ .cloned()
+ .collect();
+ locations.extend(roots.iter().cloned().map(|path| AdapterLocation {
+ agent,
+ enabled: !disabled.contains(&(agent, path.clone())),
+ path,
+ individually_removable,
+ }));
+
+ if excluded.is_empty() {
+ active.push(adapter);
+ } else if excluded.len() < roots.len() {
+ // 只有多根 adapter 会到这里。若某个新 adapter 尚未实现局部裁剪,
+ // 保守地整实例停用,绝不能继续扫描用户明确关掉的路径。
+ if let Some(filtered) = adapter.excluding_data_roots(&excluded) {
+ if !filtered.data_roots().is_empty() {
+ active.push(filtered);
+ }
+ }
+ }
+ }
+
+ AdapterRoster { active, locations }
+}
+
/// 按索引库里的 location 配置构造 roster——**所有打开真实索引库的入口**
/// (GUI 与 scan CLI)都必须走这里:用默认 roster 对配置过的库跑 run_scan,
/// 删除检测会把自定义根的会话当"磁盘已删"整批清掉,再把被压制的默认根加回
/// (2026-08-24 Codex review 抓到 scan bin 正是这么毁数据的)
pub fn create_adapters_for(store: &crate::db::Store) -> Vec<Box<dyn AgentAdapter>> {
- let (customs, removed, removed_roots) = store.location_overrides();
- create_adapters_with_root_overrides(&customs, &removed, &removed_roots)
+ create_adapter_roster_for(store).active
}
/// 数据根是否拥有该会话文件路径。边界必须落在分隔符(目录型)或 '#'(SQLite
diff --git a/crates/wake-core/src/db.rs b/crates/wake-core/src/db.rs
index e907287..873ced5 100644
--- a/crates/wake-core/src/db.rs
+++ b/crates/wake-core/src/db.rs
@@ -85,6 +85,13 @@ CREATE TABLE IF NOT EXISTS removed_default_roots (
removed_at INTEGER,
PRIMARY KEY (agent, path)
);
+
+CREATE TABLE IF NOT EXISTS disabled_locations (
+ agent TEXT NOT NULL,
+ path TEXT NOT NULL,
+ disabled_at INTEGER,
+ PRIMARY KEY (agent, path)
+);
"#;
fn open_conn(path: &Path) -> Result<Connection> {
@@ -105,7 +112,7 @@ fn open_conn(path: &Path) -> Result<Connection> {
/// 打开索引库;打不开就把它连同 WAL/SHM 一起挪到 `.corrupt` 旁路再建一个空的。
/// 索引本来就能从磁盘全量重扫恢复,重建的真实损失只有 user_data(收藏/置顶)
-/// 与 custom_roots(自定义 location)——而它远好过 GUI 无提示秒退。
+/// 与 location 配置——而它远好过 GUI 无提示秒退。
/// 返回的 `Some(_)` 是给用户看的说明文案。
pub fn open_or_rebuild(path: &Path) -> Result<(Store, Option<String>)> {
let first = match Store::open(path) {
@@ -119,13 +126,12 @@ pub fn open_or_rebuild(path: &Path) -> Result<(Store, Option<String>)> {
for suffix in ["-wal", "-shm"] {
let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));
}
- let store = Store::open(path)
- .with_context(|| format!("rebuild failed after: {first}"))?;
+ let store = Store::open(path).with_context(|| format!("rebuild failed after: {first}"))?;
Ok((
store,
Some(format!(
- "Index was damaged and has been rebuilt — stars, pins and custom \
- locations are gone. The old file is kept at {}",
+ "Index was damaged and has been rebuilt — stars, pins and location \
+ settings are gone. The old file is kept at {}",
backup.display()
)),
))
@@ -147,7 +153,12 @@ impl Store {
// ---------- 写路径(扫描器/用户操作) ----------
- pub fn write_session(&self, meta: &SessionMeta, file_mtime: i64, units: &[IndexUnit]) -> Result<()> {
+ pub fn write_session(
+ &self,
+ meta: &SessionMeta,
+ file_mtime: i64,
+ units: &[IndexUnit],
+ ) -> Result<()> {
let mut conn = self.write.lock().unwrap();
let tx = conn.transaction()?;
write_session_tx(&tx, meta, file_mtime, units)?;
@@ -201,14 +212,20 @@ impl Store {
let tx = conn.transaction()?;
{
let file_path: Option<String> = tx
- .query_row("SELECT file_path FROM sessions WHERE key = ?1", params![key], |r| r.get(0))
+ .query_row(
+ "SELECT file_path FROM sessions WHERE key = ?1",
+ params![key],
+ |r| r.get(0),
+ )
.optional()?;
- let mut sel = tx.prepare_cached("SELECT id, text FROM messages WHERE session_key = ?1")?;
+ let mut sel =
+ tx.prepare_cached("SELECT id, text FROM messages WHERE session_key = ?1")?;
let rows: Vec<(i64, String)> = sel
.query_map(params![key], |r| Ok((r.get(0)?, r.get(1)?)))?
.collect::<rusqlite::Result<_>>()?;
- let mut fts_del =
- tx.prepare_cached("INSERT INTO messages_fts(messages_fts, rowid, text) VALUES ('delete', ?1, ?2)")?;
+ let mut fts_del = tx.prepare_cached(
+ "INSERT INTO messages_fts(messages_fts, rowid, text) VALUES ('delete', ?1, ?2)",
+ )?;
for (id, text) in rows {
fts_del.execute(params![id, text])?;
}
@@ -257,7 +274,12 @@ impl Store {
Ok(key)
}
- pub fn set_user_data(&self, key: &str, favorite: Option<bool>, pinned: Option<bool>) -> Result<()> {
+ pub fn set_user_data(
+ &self,
+ key: &str,
+ favorite: Option<bool>,
+ pinned: Option<bool>,
+ ) -> Result<()> {
let conn = self.write.lock().unwrap();
conn.execute(
"INSERT INTO user_data(session_key, favorite, pinned, updated_at)
@@ -266,7 +288,12 @@ impl Store {
favorite = COALESCE(?2, user_data.favorite),
pinned = COALESCE(?3, user_data.pinned),
updated_at = excluded.updated_at",
- params![key, favorite.map(|v| v as i64), pinned.map(|v| v as i64), now_ms()],
+ params![
+ key,
+ favorite.map(|v| v as i64),
+ pinned.map(|v| v as i64),
+ now_ms()
+ ],
)?;
Ok(())
}
@@ -316,6 +343,43 @@ impl Store {
(customs, removed, removed_roots)
}
+ /// 被用户暂时停用的数据根。与 removed_defaults 不同:停用只控制扫描,
+ /// location 配置本身仍在,因此管理面板可以原位重新开启。
+ pub fn disabled_locations(&self) -> Vec<(AgentId, std::path::PathBuf)> {
+ self.list_disabled_locations()
+ .unwrap_or_default()
+ .into_iter()
+ .filter_map(|(a, p)| AgentId::from_str(&a).map(|a| (a, std::path::PathBuf::from(p))))
+ .collect()
+ }
+
+ pub fn list_disabled_locations(&self) -> Result<Vec<(String, String)>> {
+ let conn = self.read.lock().unwrap();
+ let mut stmt = conn.prepare_cached(
+ "SELECT agent, path FROM disabled_locations ORDER BY disabled_at, agent, path",
+ )?;
+ let rows = stmt.query_map([], |r| Ok((r.get(0)?, r.get(1)?)))?;
+ Ok(rows.flatten().collect())
+ }
+
+ /// location 开关的唯一写入口。enabled=true 删除停用标记;false 幂等记入。
+ pub fn set_location_enabled(&self, agent: &str, path: &str, enabled: bool) -> Result<()> {
+ let conn = self.write.lock().unwrap();
+ if enabled {
+ conn.execute(
+ "DELETE FROM disabled_locations WHERE agent = ?1 AND path = ?2",
+ params![agent, path],
+ )?;
+ } else {
+ conn.execute(
+ "INSERT OR IGNORE INTO disabled_locations(agent, path, disabled_at)
+ VALUES (?1, ?2, ?3)",
+ params![agent, path, now_ms()],
+ )?;
+ }
+ Ok(())
+ }
+
/// 编辑 location 的全形态原子写入(2026-08-24 Codex review:分开自动提交
/// 时第二步失败会把配置改成半生效)。旧单元:自定义 = 删记录,普通预设 =
/// 压整家默认,多产品库预设 = 只压该 root;新单元一律记自定义——含换
@@ -325,11 +389,34 @@ impl Store {
old_agent: &str,
old_custom_path: Option<&str>,
old_default_root: Option<&str>,
+ old_data_root: &str,
new_agent: &str,
new_path: &str,
) -> Result<()> {
let mut conn = self.write.lock().unwrap();
let tx = conn.transaction()?;
+ // 编辑被停用的 location 后,新路径按启用状态开始;旧路径留下停用记录
+ // 会在用户日后重新添加同一路径时意外继承,因此随旧配置一并清理。
+ let disabled: Vec<String> = {
+ let mut stmt = tx.prepare_cached(
+ "SELECT path FROM disabled_locations WHERE agent = ?1 ORDER BY path",
+ )?;
+ let rows = stmt.query_map(params![old_agent], |r| r.get(0))?;
+ rows.flatten().collect()
+ };
+ // 自定义配置可能派生多个数据根,按落库父路径整组清;内置配置则按
+ // 用户正在编辑的真实数据根清。old_default_root 只管 Remove/替换语义,
+ // 不能兼任这里的状态键(多数 adapter 在该参数中是 None)。
+ let disabled_unit = old_custom_path.unwrap_or(old_data_root);
+ for path in disabled
+ .iter()
+ .filter(|path| crate::adapters::path_owns(disabled_unit, path))
+ {
+ tx.execute(
+ "DELETE FROM disabled_locations WHERE agent = ?1 AND path = ?2",
+ params![old_agent, path],
+ )?;
+ }
match (old_custom_path, old_default_root) {
(Some(p), _) => {
tx.execute(
@@ -358,13 +445,14 @@ impl Store {
Ok(())
}
- /// 恢复初始:清空全部 location 偏离(自定义 + 被移除的预设/预设路径)
+ /// 恢复初始:清空全部 location 偏离(自定义、被移除预设与停用状态)。
pub fn clear_location_overrides(&self) -> Result<()> {
let conn = self.write.lock().unwrap();
conn.execute_batch(
"DELETE FROM custom_roots;
DELETE FROM removed_defaults;
- DELETE FROM removed_default_roots;",
+ DELETE FROM removed_default_roots;
+ DELETE FROM disabled_locations;",
)?;
Ok(())
}
@@ -408,11 +496,31 @@ impl Store {
}
pub fn remove_custom_root(&self, agent: &str, path: &str) -> Result<()> {
- let conn = self.write.lock().unwrap();
- conn.execute(
+ let mut conn = self.write.lock().unwrap();
+ let tx = conn.transaction()?;
+ tx.execute(
"DELETE FROM custom_roots WHERE agent = ?1 AND path = ?2",
params![agent, path],
)?;
+ // 同一配置可能派生多个真实根(如 Codex sessions + archived);真正
+ // Remove 时一并清掉这些根的停用标记,今后重新添加应默认启用。
+ let disabled: Vec<String> = {
+ let mut stmt = tx.prepare_cached(
+ "SELECT path FROM disabled_locations WHERE agent = ?1 ORDER BY path",
+ )?;
+ let rows = stmt.query_map(params![agent], |r| r.get(0))?;
+ rows.flatten().collect()
+ };
+ for disabled_path in disabled
+ .iter()
+ .filter(|disabled_path| crate::adapters::path_owns(path, disabled_path))
+ {
+ tx.execute(
+ "DELETE FROM disabled_locations WHERE agent = ?1 AND path = ?2",
+ params![agent, disabled_path],
+ )?;
+ }
+ tx.commit()?;
Ok(())
}
@@ -428,7 +536,8 @@ impl Store {
pub fn known_files(&self) -> Result<HashMap<String, (i64, i64, String)>> {
let conn = self.read.lock().unwrap();
- let mut stmt = conn.prepare_cached("SELECT file_path, file_mtime, file_size, key FROM sessions")?;
+ let mut stmt =
+ conn.prepare_cached("SELECT file_path, file_mtime, file_size, key FROM sessions")?;
let rows = stmt.query_map([], |r| {
Ok((r.get::<_, String>(0)?, (r.get(1)?, r.get(2)?, r.get(3)?)))
})?;
@@ -576,8 +685,9 @@ impl Store {
pub fn agent_counts(&self) -> Result<HashMap<String, i64>> {
let conn = self.read.lock().unwrap();
- let mut stmt =
- conn.prepare_cached("SELECT agent_id, COUNT(*) FROM sessions WHERE archived = 0 GROUP BY agent_id")?;
+ let mut stmt = conn.prepare_cached(
+ "SELECT agent_id, COUNT(*) FROM sessions WHERE archived = 0 GROUP BY agent_id",
+ )?;
let rows = stmt.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?)))?;
let mut map = HashMap::new();
for r in rows {
@@ -714,7 +824,14 @@ impl Store {
},
)?;
for r in rows {
- let (k, seq, sc, role, ts, text): (String, i64, Option<String>, String, Option<i64>, String) = r?;
+ let (k, seq, sc, role, ts, text): (
+ String,
+ i64,
+ Option<String>,
+ String,
+ Option<i64>,
+ String,
+ ) = r?;
raw.push((k, seq, sc, role, ts, make_like_snippet(&text, segs[0])));
}
}
@@ -740,7 +857,8 @@ impl Store {
}
}
-const SESSION_COLS: &str = "s.key, s.agent_id, s.native_id, s.title, s.project_path, s.project_name,
+const SESSION_COLS: &str =
+ "s.key, s.agent_id, s.native_id, s.title, s.project_path, s.project_name,
s.git_branch, s.created_at, s.updated_at, s.message_count, s.tokens_used, s.model, s.source,
s.archived, s.file_path, s.file_size, COALESCE(u.favorite,0), COALESCE(u.pinned,0)";
@@ -788,7 +906,10 @@ fn write_session_tx(
fts_del.execute(params![id, text])?;
}
drop(fts_del);
- tx.execute("DELETE FROM messages WHERE session_key = ?1", params![meta.key])?;
+ tx.execute(
+ "DELETE FROM messages WHERE session_key = ?1",
+ params![meta.key],
+ )?;
upsert_session(tx, meta, file_mtime)?;
@@ -849,7 +970,9 @@ fn upsert_session(tx: &rusqlite::Transaction<'_>, m: &SessionMeta, file_mtime: i
}
fn escape_like(s: &str) -> String {
- s.replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_")
+ s.replace('\\', "\\\\")
+ .replace('%', "\\%")
+ .replace('_', "\\_")
}
fn make_like_snippet(text: &str, first_seg: &str) -> String {
diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rs
index 3c58c55..34ad5dc 100644
--- a/crates/wake-core/tests/adapter_contracts.rs
+++ b/crates/wake-core/tests/adapter_contracts.rs
@@ -296,13 +296,16 @@ fn build_antigravity_db(path: &Path) {
// ---------------------------------------------------------------- 小工具
fn fixture(rel: &str) -> PathBuf {
- Path::new(env!("CARGO_MANIFEST_DIR")).join("tests").join("fixtures").join(rel)
+ Path::new(env!("CARGO_MANIFEST_DIR"))
+ .join("tests")
+ .join("fixtures")
+ .join(rel)
}
/// 文件型 agent 的 SessionFileRef(直接指 fixture,不走 list_session_files)
fn fs_ref(agent: AgentId, path: &Path, native_id: &str) -> SessionFileRef {
- let meta = fs::metadata(path)
- .unwrap_or_else(|e| panic!("fixture missing {}: {e}", path.display()));
+ let meta =
+ fs::metadata(path).unwrap_or_else(|e| panic!("fixture missing {}: {e}", path.display()));
SessionFileRef {
agent,
native_id: native_id.to_string(),
@@ -329,7 +332,9 @@ fn db_ref(agent: AgentId, db: &Path, id: &str) -> SessionFileRef {
}
fn ms(rfc3339: &str) -> i64 {
- chrono::DateTime::parse_from_rfc3339(rfc3339).expect("test timestamp").timestamp_millis()
+ chrono::DateTime::parse_from_rfc3339(rfc3339)
+ .expect("test timestamp")
+ .timestamp_millis()
}
fn roles_kinds(mainline: &[TranscriptMessage]) -> Vec<(Role, MessageKind)> {
@@ -403,7 +408,9 @@ fn claude_parse_contract() {
let adapter = ClaudeAdapter::new();
let r = claude_ref();
let s = adapter.parse_session(&r).expect("claude parse_session");
- let t = adapter.parse_transcript(&r).expect("claude parse_transcript");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("claude parse_transcript");
// 标题=最后一条 custom-title,压过首条用户消息推导
assert_eq!(s.meta.title, "QR login revamp");
@@ -437,11 +444,18 @@ fn claude_parse_contract() {
assert_eq!(a.tool_calls.len(), 1);
assert_eq!(a.tool_calls[0].name, "Read");
// tool_result 在后续 user 行,应回填到 tool_use
- assert!(a.tool_calls[0].output.as_deref().unwrap_or_default().contains("useEffect"));
+ assert!(a.tool_calls[0]
+ .output
+ .as_deref()
+ .unwrap_or_default()
+ .contains("useEffect"));
assert!(!a.tool_calls[0].is_error);
// units 只含 Text 消息,tool 名与 input 摘要并入正文
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![1, 2, 3]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![1, 2, 3]
+ );
assert!(s.units[1].text.contains("Login.tsx"));
// 无真实用户消息的变体 → UNTITLED
@@ -450,7 +464,9 @@ fn claude_parse_contract() {
&fixture("claude/projects/-Users-tester-Github-wakefx/aaaaaaaa-0000-4000-8000-00000000000a.jsonl"),
"aaaaaaaa-0000-4000-8000-00000000000a",
);
- let s2 = adapter.parse_session(&untitled).expect("claude untitled parse");
+ let s2 = adapter
+ .parse_session(&untitled)
+ .expect("claude untitled parse");
assert_eq!(s2.meta.title, UNTITLED);
assert_eq!(s2.meta.message_count, 1);
}
@@ -465,7 +481,9 @@ fn codex_parse_contract() {
assert_eq!(r.native_id, "22222222-aaaa-bbbb-cccc-000000000002");
let s = adapter.parse_session(&r).expect("codex parse_session");
- let t = adapter.parse_transcript(&r).expect("codex parse_transcript");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("codex parse_transcript");
// 标题取首条真实用户消息(environment_context 注入行归 Meta 被跳过)
assert_eq!(s.meta.title, "扫码登录报错,帮我查一下 useEffect() 依赖数组");
@@ -499,10 +517,17 @@ fn codex_parse_contract() {
assert!(!thinking.contains("OPAQUE-CIPHERTEXT"));
assert_eq!(host.tool_calls.len(), 1);
assert_eq!(host.tool_calls[0].name, "shell");
- assert!(host.tool_calls[0].output.as_deref().unwrap_or_default().contains("QrScanner"));
+ assert!(host.tool_calls[0]
+ .output
+ .as_deref()
+ .unwrap_or_default()
+ .contains("QrScanner"));
// 空文本的 reasoning 宿主凭 tool call 进入 units
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![1, 2, 3]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![1, 2, 3]
+ );
}
#[test]
@@ -511,7 +536,9 @@ fn copilot_parse_contract() {
let adapter = CopilotAdapter::new();
let r = db_ref(AgentId::Copilot, &env.copilot_db, "cop-0001");
let s = adapter.parse_session(&r).expect("copilot parse_session");
- let t = adapter.parse_transcript(&r).expect("copilot parse_transcript");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("copilot parse_transcript");
assert_eq!(s.meta.title, "Copilot QR fix"); // summary 优先
assert_eq!(s.meta.git_branch.as_deref(), Some("main"));
@@ -532,7 +559,10 @@ fn copilot_parse_contract() {
]
);
assert_eq!(t.mainline[0].timestamp, Some(ms("2026-08-05T09:05:00Z")));
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![0, 1, 2]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 1, 2]
+ );
// summary 为空的会话回退首条用户消息作标题
let r2 = db_ref(AgentId::Copilot, &env.copilot_db, "cop-0002");
@@ -547,10 +577,15 @@ fn cursor_parse_contract() {
let adapter = CursorAdapter::new();
let r = cursor_ref();
let s = adapter.parse_session(&r).expect("cursor parse_session");
- let t = adapter.parse_transcript(&r).expect("cursor parse_transcript");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("cursor parse_transcript");
// 标题取 <user_query> 壳内正文;无壳的注入行(<workspace>)归 Meta 被跳过
- assert_eq!(s.meta.title, "把二维码扫描组件抽出来,注意 useEffect() 的清理");
+ assert_eq!(
+ s.meta.title,
+ "把二维码扫描组件抽出来,注意 useEffect() 的清理"
+ );
// slug 目录 "wakefx-cursor-proj" 磁盘上无对应真实路径 → 直译回退
assert_eq!(s.meta.project_path, "/wakefx/cursor/proj");
assert_eq!(s.meta.project_name, "proj");
@@ -568,12 +603,18 @@ fn cursor_parse_contract() {
(Role::User, MessageKind::Text),
]
);
- assert_eq!(t.mainline[1].timestamp, Some(ms("2026-08-01T09:30:00+08:00")));
+ assert_eq!(
+ t.mainline[1].timestamp,
+ Some(ms("2026-08-01T09:30:00+08:00"))
+ );
let a = &t.mainline[2];
assert_eq!(a.tool_calls.len(), 1);
assert_eq!(a.tool_calls[0].name, "read_file");
assert_eq!(a.tool_calls[0].output, None); // transcript 不落盘工具结果
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![1, 2, 3]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![1, 2, 3]
+ );
}
#[test]
@@ -582,7 +623,9 @@ fn opencode_parse_contract() {
let adapter = OpencodeAdapter::new();
let r = db_ref(AgentId::Opencode, &env.opencode_db, "oc-0001");
let s = adapter.parse_session(&r).expect("opencode parse_session");
- let t = adapter.parse_transcript(&r).expect("opencode parse_transcript");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("opencode parse_transcript");
assert_eq!(s.meta.title, "OpenCode 二维码排查"); // session 表自带标题
assert_eq!(s.meta.project_name, "wakefx");
@@ -603,12 +646,23 @@ fn opencode_parse_contract() {
]
);
let a = &t.mainline[2];
- assert!(a.thinking.as_deref().unwrap_or_default().contains("先查 effect 依赖"));
+ assert!(a
+ .thinking
+ .as_deref()
+ .unwrap_or_default()
+ .contains("先查 effect 依赖"));
assert_eq!(a.tool_calls.len(), 1);
assert_eq!(a.tool_calls[0].name, "grep");
- assert!(a.tool_calls[0].output.as_deref().unwrap_or_default().contains("QrScanner"));
+ assert!(a.tool_calls[0]
+ .output
+ .as_deref()
+ .unwrap_or_default()
+ .contains("QrScanner"));
assert!(!a.tool_calls[0].is_error);
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![1, 2]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![1, 2]
+ );
}
#[test]
@@ -630,12 +684,18 @@ fn kiro_parse_contract() {
assert_eq!(
roles_kinds(&t.mainline),
- vec![(Role::User, MessageKind::Text), (Role::Assistant, MessageKind::Text)]
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text)
+ ]
);
// jsonl 的 timestamp 是 unix 秒,应换算成 ms
assert_eq!(t.mainline[0].timestamp, Some(1785744300000));
assert_eq!(t.mainline[1].timestamp, Some(1785744360000));
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![0, 1]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 1]
+ );
}
#[test]
@@ -644,14 +704,19 @@ fn gemini_parse_contract() {
let adapter = GeminiAdapter::new();
let r = gemini_ref();
let s = adapter.parse_session(&r).expect("gemini parse_session");
- let t = adapter.parse_transcript(&r).expect("gemini parse_transcript");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("gemini parse_transcript");
// $set 是覆盖式快照:只认最后一条,旧快照文本不得出现
assert_eq!(t.mainline.len(), 2);
assert!(t.mainline.iter().all(|m| !m.text.contains("旧快照")));
assert_eq!(
roles_kinds(&t.mainline),
- vec![(Role::User, MessageKind::Text), (Role::Assistant, MessageKind::Text)]
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text)
+ ]
);
// id 取 header 的 sessionId(非文件名 stem)
@@ -664,7 +729,10 @@ fn gemini_parse_contract() {
assert_eq!(s.meta.updated_at, ms("2026-08-04T12:20:00Z"));
assert_eq!(s.meta.message_count, 2);
assert_eq!(s.unknown_line_count, 1);
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![0, 1]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 1]
+ );
}
#[test]
@@ -683,8 +751,12 @@ fn opencode_v2_parse_contract() {
assert!(ids.contains("oc-0001"), "仅存于 v1 表的会话应被 UNION 回捞");
let r = db_ref(AgentId::Opencode, &env.opencode_db, "ocv2-0001");
- let s = adapter.parse_session(&r).expect("opencode v2 parse_session");
- let t = adapter.parse_transcript(&r).expect("opencode v2 parse_transcript");
+ let s = adapter
+ .parse_session(&r)
+ .expect("opencode v2 parse_session");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("opencode v2 parse_transcript");
assert_eq!(s.meta.title, "OpenCode v2 greeting");
assert_eq!(s.meta.model.as_deref(), Some("nemotron-3.5-lightning-free"));
@@ -706,9 +778,16 @@ fn opencode_v2_parse_contract() {
assert_eq!(t.mainline[0].text, "OpenCode v2 看看二维码组件");
let a = &t.mainline[2];
assert_eq!(a.text, "看完了,组件没有泄漏。");
- assert!(a.thinking.as_deref().unwrap_or_default().contains("扫描组件"));
+ assert!(a
+ .thinking
+ .as_deref()
+ .unwrap_or_default()
+ .contains("扫描组件"));
assert_eq!(a.model.as_deref(), Some("nemotron-3.5-lightning-free"));
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![0, 2]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 2]
+ );
// 仅存于 v1 表的会话不带 v2 标记(resume 走 v1 二进制)
let s1 = adapter
@@ -722,15 +801,25 @@ fn opencode_next_real_schema_contract() {
let env = setup();
let adapter = OpencodeAdapter::new();
let roots = adapter.data_roots();
- assert!(roots.contains(&env.opencode_db), "stable 数据库路径必须保留");
- assert!(roots.contains(&env.opencode_next_db), "next 数据库路径必须新增扫描");
+ assert!(
+ roots.contains(&env.opencode_db),
+ "stable 数据库路径必须保留"
+ );
+ assert!(
+ roots.contains(&env.opencode_next_db),
+ "next 数据库路径必须新增扫描"
+ );
- let refs = adapter.list_session_files().expect("opencode stable + next list");
+ let refs = adapter
+ .list_session_files()
+ .expect("opencode stable + next list");
let r = refs
.iter()
.find(|r| r.native_id == "ocnext-0001")
.expect("真实 session + session_message 会话应被列出");
- assert!(r.file_path.starts_with(env.opencode_next_db.to_string_lossy().as_ref()));
+ assert!(r
+ .file_path
+ .starts_with(env.opencode_next_db.to_string_lossy().as_ref()));
let quick = adapter.quick_meta(&refs).expect("opencode next quick meta");
assert_eq!(
quick.get(&r.file_path).and_then(|m| m.source.as_deref()),
@@ -738,8 +827,12 @@ fn opencode_next_real_schema_contract() {
"列表快路径也必须带 preview 标记"
);
- let s = adapter.parse_session(r).expect("opencode next parse_session");
- let t = adapter.parse_transcript(r).expect("opencode next parse_transcript");
+ let s = adapter
+ .parse_session(r)
+ .expect("opencode next parse_session");
+ let t = adapter
+ .parse_transcript(r)
+ .expect("opencode next parse_transcript");
assert_eq!(s.meta.title, "OpenCode next real schema");
assert_eq!(s.meta.model.as_deref(), Some("gpt-5.6"));
assert_eq!(s.meta.tokens_used, Some(32));
@@ -760,14 +853,24 @@ fn opencode_next_real_schema_contract() {
);
let assistant = &t.mainline[2];
assert_eq!(assistant.text, "next schema 解析成功。");
- assert!(assistant.thinking.as_deref().unwrap_or_default().contains("effect 清理"));
+ assert!(assistant
+ .thinking
+ .as_deref()
+ .unwrap_or_default()
+ .contains("effect 清理"));
assert_eq!(assistant.tool_calls.len(), 1);
assert_eq!(assistant.tool_calls[0].id, "tool-1");
assert_eq!(assistant.tool_calls[0].name, "grep");
- assert_eq!(assistant.tool_calls[0].output.as_deref(), Some("src/QrScanner.tsx:42"));
+ assert_eq!(
+ assistant.tool_calls[0].output.as_deref(),
+ Some("src/QrScanner.tsx:42")
+ );
assert_eq!(t.mainline[4].tool_calls[0].name, "shell");
assert_eq!(t.mainline[5].kind, MessageKind::CompactSummary);
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![0, 2, 4]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 2, 4]
+ );
}
#[test]
@@ -830,20 +933,32 @@ fn pi_parse_contract() {
// 连续 assistant 行(中间只隔 toolResult)合并成一条
assert_eq!(
roles_kinds(&t.mainline),
- vec![(Role::User, MessageKind::Text), (Role::Assistant, MessageKind::Text)]
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text)
+ ]
);
let a = &t.mainline[1];
assert_eq!(a.text, "找到泄漏点,已补清理回调。");
assert_eq!(a.tool_calls.len(), 1);
assert_eq!(a.tool_calls[0].name, "bash");
// toolResult 是独立 role 行,按 toolCallId 回填
- assert!(a.tool_calls[0].output.as_deref().unwrap_or_default().contains("QrScanner"));
+ assert!(a.tool_calls[0]
+ .output
+ .as_deref()
+ .unwrap_or_default()
+ .contains("QrScanner"));
assert!(!a.tool_calls[0].is_error);
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![0, 1]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 1]
+ );
// omp 是 pi 的 fork,同一解析核心,只有 key 前缀不同
let omp = PiAdapter::omp();
- let s2 = omp.parse_session(&pi_ref(AgentId::Omp)).expect("omp parse_session");
+ let s2 = omp
+ .parse_session(&pi_ref(AgentId::Omp))
+ .expect("omp parse_session");
assert_eq!(s2.meta.agent, AgentId::Omp);
assert_eq!(s2.meta.key, "omp:66666666-aaaa-bbbb-cccc-000000000006");
assert_eq!(s2.meta.title, "Pi 查一下二维码组件的 useEffect() 清理");
@@ -857,7 +972,9 @@ fn grok_parse_contract() {
let path = fixture("grok/sessions/%2FUsers%2Ftester%2FGithub%2Fwakefx/77777777-aaaa-bbbb-cccc-000000000007/updates.jsonl");
let r = adapter.file_ref(&path).expect("grok file_ref");
assert_eq!(r.native_id, "77777777-aaaa-bbbb-cccc-000000000007");
- assert!(adapter.file_ref(&path.with_file_name("chat_history.jsonl")).is_none());
+ assert!(adapter
+ .file_ref(&path.with_file_name("chat_history.jsonl"))
+ .is_none());
let s = adapter.parse_session(&r).expect("grok parse_session");
let t = adapter.parse_transcript(&r).expect("grok parse_transcript");
@@ -874,19 +991,36 @@ fn grok_parse_contract() {
// chunk 流按角色段合并:两条 user chunk 拼成一条,thought/message/tool 全并入一条 assistant
assert_eq!(
roles_kinds(&t.mainline),
- vec![(Role::User, MessageKind::Text), (Role::Assistant, MessageKind::Text)]
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text)
+ ]
+ );
+ assert_eq!(
+ t.mainline[0].text,
+ "Grok 看看二维码扫描,重点 useEffect() 清理"
);
- assert_eq!(t.mainline[0].text, "Grok 看看二维码扫描,重点 useEffect() 清理");
assert_eq!(t.mainline[0].timestamp, Some(1786014300000));
let a = &t.mainline[1];
assert_eq!(a.text, "已定位泄漏,补了清理回调。");
- assert!(a.thinking.as_deref().unwrap_or_default().contains("effect 泄漏"));
+ assert!(a
+ .thinking
+ .as_deref()
+ .unwrap_or_default()
+ .contains("effect 泄漏"));
assert_eq!(a.tool_calls.len(), 1);
assert_eq!(a.tool_calls[0].name, "Grep");
// tool_call_update 的 content 文本回填 output;字节数组 rawOutput 不碰
- assert!(a.tool_calls[0].output.as_deref().unwrap_or_default().contains("found 2 matches"));
+ assert!(a.tool_calls[0]
+ .output
+ .as_deref()
+ .unwrap_or_default()
+ .contains("found 2 matches"));
assert!(!a.tool_calls[0].is_error);
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![0, 1]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 1]
+ );
}
#[test]
@@ -902,7 +1036,7 @@ fn kimi_parse_contract() {
let t = adapter.parse_transcript(&r).expect("kimi parse_transcript");
assert_eq!(s.meta.title, "Kimi QR fix"); // state.json 标题优先
- // cwd 靠假 HOME 的 session_index.jsonl 反查(目录名 hash 不可反推)
+ // cwd 靠假 HOME 的 session_index.jsonl 反查(目录名 hash 不可反推)
assert_eq!(s.meta.project_path, "/Users/tester/Github/wakefx");
assert_eq!(s.meta.created_at, ms("2026-08-06T12:00:00Z"));
assert_eq!(s.meta.updated_at, ms("2026-08-06T12:30:00Z"));
@@ -912,11 +1046,20 @@ fn kimi_parse_contract() {
assert_eq!(
roles_kinds(&t.mainline),
- vec![(Role::User, MessageKind::Text), (Role::Assistant, MessageKind::Text)]
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text)
+ ]
+ );
+ assert_eq!(
+ t.mainline[0].text,
+ "Kimi 修一下二维码组件的 useEffect() 内存泄漏"
);
- assert_eq!(t.mainline[0].text, "Kimi 修一下二维码组件的 useEffect() 内存泄漏");
assert!(t.mainline[1].text.contains("QrScanner"));
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![0, 1]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 1]
+ );
// "New Session" 是占位标题,必须回退首条用户消息
let placeholder = fs_ref(
@@ -924,7 +1067,9 @@ fn kimi_parse_contract() {
&fixture("kimi/sessions/wd_wakefx_abc123/session_99999999-aaaa-bbbb-cccc-000000000009/agents/main/wire.jsonl"),
"session_99999999-aaaa-bbbb-cccc-000000000009",
);
- let s2 = adapter.parse_session(&placeholder).expect("kimi placeholder parse");
+ let s2 = adapter
+ .parse_session(&placeholder)
+ .expect("kimi placeholder parse");
assert_eq!(s2.meta.title, "占位标题会话应回退到这句");
}
@@ -939,8 +1084,12 @@ fn antigravity_parse_contract() {
assert_eq!(refs[0].native_id, "ag-0001");
let r = db_ref(AgentId::Antigravity, &env.antigravity_db, "ag-0001");
- let s = adapter.parse_session(&r).expect("antigravity parse_session");
- let t = adapter.parse_transcript(&r).expect("antigravity parse_transcript");
+ let s = adapter
+ .parse_session(&r)
+ .expect("antigravity parse_session");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("antigravity parse_transcript");
assert_eq!(s.meta.title, "QR overlay polish"); // 标题在 preview 列
assert_eq!(s.meta.project_path, "/Users/tester/Github/wakefx"); // file:// URI 解码
@@ -951,7 +1100,10 @@ fn antigravity_parse_contract() {
assert!(s.meta.file_path.ends_with("#ag-0001")); // 虚拟路径
// 正文加密:唯一一条 System 消息承载 preview 与说明,FTS 搜得到 preview
- assert_eq!(roles_kinds(&t.mainline), vec![(Role::System, MessageKind::Text)]);
+ assert_eq!(
+ roles_kinds(&t.mainline),
+ vec![(Role::System, MessageKind::Text)]
+ );
assert!(t.mainline[0].text.contains("QR overlay polish"));
assert!(t.mainline[0].text.contains("encrypted"));
assert_eq!(s.units.len(), 1);
@@ -964,18 +1116,29 @@ fn antigravity_parse_contract() {
/// 且 mainline seq 从 0 严格递增(搜索跳转按 seq 定位依赖此契约)。
fn assert_seq_contract(adapter: &dyn AgentAdapter, r: &SessionFileRef) {
let tag = r.agent.as_str();
- let s = adapter.parse_session(r).unwrap_or_else(|e| panic!("[{tag}] parse_session: {e}"));
- let t = adapter.parse_transcript(r).unwrap_or_else(|e| panic!("[{tag}] parse_transcript: {e}"));
+ let s = adapter
+ .parse_session(r)
+ .unwrap_or_else(|e| panic!("[{tag}] parse_session: {e}"));
+ let t = adapter
+ .parse_transcript(r)
+ .unwrap_or_else(|e| panic!("[{tag}] parse_transcript: {e}"));
assert!(!t.mainline.is_empty(), "[{tag}] mainline 不应为空");
for (i, m) in t.mainline.iter().enumerate() {
assert_eq!(m.seq, i as i64, "[{tag}] mainline seq 必须从 0 严格递增");
}
- assert!(!s.units.is_empty(), "[{tag}] fixture 应产出至少一个 FTS 单元");
+ assert!(
+ !s.units.is_empty(),
+ "[{tag}] fixture 应产出至少一个 FTS 单元"
+ );
let seqs: HashSet<i64> = t.mainline.iter().map(|m| m.seq).collect();
for u in &s.units {
- assert!(seqs.contains(&u.seq), "[{tag}] unit seq {} 在 mainline 中不存在", u.seq);
+ assert!(
+ seqs.contains(&u.seq),
+ "[{tag}] unit seq {} 在 mainline 中不存在",
+ u.seq
+ );
let m = &t.mainline[u.seq as usize];
assert_eq!(m.role, u.role, "[{tag}] seq {} 两侧角色不一致", u.seq);
}
@@ -983,7 +1146,10 @@ fn assert_seq_contract(adapter: &dyn AgentAdapter, r: &SessionFileRef) {
// 两条解析路径共用核心解析器,meta 关键字段必须一致
assert_eq!(s.meta.key, t.meta.key, "[{tag}] key 两侧不一致");
assert_eq!(s.meta.title, t.meta.title, "[{tag}] title 两侧不一致");
- assert_eq!(s.meta.message_count, t.meta.message_count, "[{tag}] message_count 两侧不一致");
+ assert_eq!(
+ s.meta.message_count, t.meta.message_count,
+ "[{tag}] message_count 两侧不一致"
+ );
}
#[test]
@@ -998,8 +1164,14 @@ fn watch_paths_derive_from_data_roots() {
let watched = a.watch_paths();
let expect: Vec<std::path::PathBuf> =
a.data_roots().into_iter().filter(|p| p.is_dir()).collect();
- assert_eq!(watched, expect, "[{tag}] watch_paths 必须等于 data_roots 的现存目录子集");
- if matches!(a.agent(), AgentId::Copilot | AgentId::Opencode | AgentId::Antigravity) {
+ assert_eq!(
+ watched, expect,
+ "[{tag}] watch_paths 必须等于 data_roots 的现存目录子集"
+ );
+ if matches!(
+ a.agent(),
+ AgentId::Copilot | AgentId::Opencode | AgentId::Antigravity
+ ) {
assert!(watched.is_empty(), "[{tag}] SQLite 型不该有监听目录");
}
}
@@ -1014,7 +1186,10 @@ fn overlapping_watch_roots_dispatch_to_deepest() {
use std::path::{Path, PathBuf};
let roots = vec![
(PathBuf::from("/h/.claude/projects"), AgentId::ClaudeCode),
- (PathBuf::from("/h/.claude/projects/codex/sessions"), AgentId::Codex),
+ (
+ PathBuf::from("/h/.claude/projects/codex/sessions"),
+ AgentId::Codex,
+ ),
];
let deep = Path::new("/h/.claude/projects/codex/sessions/2026/08/rollout-x.jsonl");
assert_eq!(
@@ -1061,7 +1236,10 @@ fn data_roots_contract() {
.map(|a| a.agent().as_str())
.collect();
for expect in ["copilot", "opencode", "antigravity", "dsh"] {
- assert!(detected.contains(&expect), "{expect} 应被检出,实际 {detected:?}");
+ assert!(
+ detected.contains(&expect),
+ "{expect} 应被检出,实际 {detected:?}"
+ );
}
}
@@ -1108,7 +1286,9 @@ fn dsh_parse_contract() {
assert!(adapter.file_ref(&sub).is_none(), "子代理会话不进列表");
// list 走 <project>/<session>/session.jsonl[.zstd] 两层布局,子代理被滤掉
- let listed = adapter.list_session_files().expect("dsh list_session_files");
+ let listed = adapter
+ .list_session_files()
+ .expect("dsh list_session_files");
assert_eq!(listed.len(), 1);
assert_eq!(listed[0].native_id, "dsh-e2e4-0001");
@@ -1124,7 +1304,10 @@ fn dsh_parse_contract() {
.and_then(|f| f.set_modified(hour_ago))
.expect("age stale sibling");
assert!(adapter.file_ref(&stale).is_none(), "陈旧 sibling 应让位");
- assert!(adapter.file_ref(&env.dsh_log).is_some(), "较新主文件不受影响");
+ assert!(
+ adapter.file_ref(&env.dsh_log).is_some(),
+ "较新主文件不受影响"
+ );
fs::remove_file(&stale).expect("remove stale sibling");
let s = adapter.parse_session(&r).expect("dsh parse_session");
@@ -1134,9 +1317,9 @@ fn dsh_parse_contract() {
assert_eq!(s.meta.key, "dsh:dsh-e2e4-0001");
assert_eq!(s.meta.project_path, "/Users/tester/Github/wakefx"); // header cwd,不反推目录名
assert_eq!(s.meta.model.as_deref(), Some("deepseek-chat-v4")); // assistant source.model
- // usage 是"one model call"的账,按调用累加(1480 + 1560 + 空载体 400)。
- // surfaceOp={op:replace} 那条是 compaction 的缩短版:整条跳过,它挂的
- // 99999 不计——它不是新的模型调用,原始节点也不该被它遮蔽
+ // usage 是"one model call"的账,按调用累加(1480 + 1560 + 空载体 400)。
+ // surfaceOp={op:replace} 那条是 compaction 的缩短版:整条跳过,它挂的
+ // 99999 不计——它不是新的模型调用,原始节点也不该被它遮蔽
assert_eq!(s.meta.tokens_used, Some(3440));
assert_eq!(s.meta.created_at, 1786100000000); // header createdAt(epoch ms)
assert_eq!(s.meta.updated_at, 1786100007000); // 最后事件 time
@@ -1158,14 +1341,25 @@ fn dsh_parse_contract() {
assert!(a.text.starts_with("我先查一下扫码组件"));
assert!(a.text.contains("依赖数组漏了 device"));
// reasoning 块分离进 thinking,不混入正文
- assert!(a.thinking.as_deref().unwrap_or_default().contains("依赖数组遗漏"));
+ assert!(a
+ .thinking
+ .as_deref()
+ .unwrap_or_default()
+ .contains("依赖数组遗漏"));
assert!(!a.text.contains("crash on unmount"));
assert_eq!(a.tool_calls.len(), 1);
assert_eq!(a.tool_calls[0].name, "read_file");
// tool/result 事件按 toolCallId 回填输出
- assert!(a.tool_calls[0].output.as_deref().unwrap_or_default().contains("useEffect"));
+ assert!(a.tool_calls[0]
+ .output
+ .as_deref()
+ .unwrap_or_default()
+ .contains("useEffect"));
assert!(!a.tool_calls[0].is_error);
- assert_eq!(s.units.iter().map(|u| u.seq).collect::<Vec<_>>(), vec![0, 1]);
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 1]
+ );
}
#[test]
@@ -1174,17 +1368,29 @@ fn seq_contract_holds_for_all_agents() {
let checks: Vec<(Box<dyn AgentAdapter>, SessionFileRef)> = vec![
(Box::new(ClaudeAdapter::new()), claude_ref()),
(Box::new(CodexAdapter::new()), codex_ref()),
- (Box::new(CopilotAdapter::new()), db_ref(AgentId::Copilot, &env.copilot_db, "cop-0001")),
+ (
+ Box::new(CopilotAdapter::new()),
+ db_ref(AgentId::Copilot, &env.copilot_db, "cop-0001"),
+ ),
(Box::new(CursorAdapter::new()), cursor_ref()),
- (Box::new(OpencodeAdapter::new()), db_ref(AgentId::Opencode, &env.opencode_db, "oc-0001")),
+ (
+ Box::new(OpencodeAdapter::new()),
+ db_ref(AgentId::Opencode, &env.opencode_db, "oc-0001"),
+ ),
(Box::new(KiroAdapter::new()), kiro_ref()),
(Box::new(GeminiAdapter::new()), gemini_ref()),
(Box::new(PiAdapter::new()), pi_ref(AgentId::Pi)),
(Box::new(PiAdapter::omp()), pi_ref(AgentId::Omp)),
(Box::new(GrokAdapter::new()), grok_ref()),
(Box::new(KimiAdapter::new()), kimi_ref()),
- (Box::new(AntigravityAdapter::new()), db_ref(AgentId::Antigravity, &env.antigravity_db, "ag-0001")),
- (Box::new(DshAdapter::new()), fs_ref(AgentId::Dsh, &env.dsh_log, "dsh-e2e4-0001")),
+ (
+ Box::new(AntigravityAdapter::new()),
+ db_ref(AgentId::Antigravity, &env.antigravity_db, "ag-0001"),
+ ),
+ (
+ Box::new(DshAdapter::new()),
+ fs_ref(AgentId::Dsh, &env.dsh_log, "dsh-e2e4-0001"),
+ ),
];
for (adapter, r) in &checks {
assert_seq_contract(adapter.as_ref(), r);
@@ -1222,8 +1428,20 @@ fn merge_quick_meta_default_vs_codex_override() {
// 默认实现(以 Claude 为代表):parsed 为准,quick 只补 source/model/tokens 缺口
let claude = ClaudeAdapter::new();
- let parsed = mk_meta(AgentId::ClaudeCode, "claude-code:p", "p", "解析出来的标题", None);
- let mut quick = mk_meta(AgentId::ClaudeCode, "claude-code:q", "q", "手动改名", Some("state"));
+ let parsed = mk_meta(
+ AgentId::ClaudeCode,
+ "claude-code:p",
+ "p",
+ "解析出来的标题",
+ None,
+ );
+ let mut quick = mk_meta(
+ AgentId::ClaudeCode,
+ "claude-code:q",
+ "q",
+ "手动改名",
+ Some("state"),
+ );
quick.model = Some("model-q".to_string());
quick.tokens_used = Some(7);
let merged = claude.merge_quick_meta(parsed, &quick);
@@ -1241,8 +1459,20 @@ fn merge_quick_meta_default_vs_codex_override() {
// Codex 覆写:state DB 的 title 是用户手动命名,压过解析标题;key/id 以
// state 的线程 id 为准;source 相反(rollout originator 更精确,quick 只兜底)
let codex = CodexAdapter::new();
- let parsed = mk_meta(AgentId::Codex, "codex:file-uuid", "file-uuid", "首条消息推导标题", Some("IDE extension"));
- let mut quick = mk_meta(AgentId::Codex, "codex:thread-1", "thread-1", "用户手动命名", Some("vscode"));
+ let parsed = mk_meta(
+ AgentId::Codex,
+ "codex:file-uuid",
+ "file-uuid",
+ "首条消息推导标题",
+ Some("IDE extension"),
+ );
+ let mut quick = mk_meta(
+ AgentId::Codex,
+ "codex:thread-1",
+ "thread-1",
+ "用户手动命名",
+ Some("vscode"),
+ );
quick.model = Some("gpt-5.2".to_string());
quick.tokens_used = Some(999);
let merged = codex.merge_quick_meta(parsed, &quick);
@@ -1254,15 +1484,33 @@ fn merge_quick_meta_default_vs_codex_override() {
assert_eq!(merged.tokens_used, Some(999));
// UNTITLED 守卫:quick 的占位标题不得覆盖解析标题,但 key/id 仍取 state
- let parsed = mk_meta(AgentId::Codex, "codex:file-uuid", "file-uuid", "首条消息推导标题", None);
- let quick = mk_meta(AgentId::Codex, "codex:thread-1", "thread-1", UNTITLED, Some("vscode"));
+ let parsed = mk_meta(
+ AgentId::Codex,
+ "codex:file-uuid",
+ "file-uuid",
+ "首条消息推导标题",
+ None,
+ );
+ let quick = mk_meta(
+ AgentId::Codex,
+ "codex:thread-1",
+ "thread-1",
+ UNTITLED,
+ Some("vscode"),
+ );
let merged = codex.merge_quick_meta(parsed, &quick);
assert_eq!(merged.title, "首条消息推导标题");
assert_eq!(merged.id, "thread-1");
assert_eq!(merged.source.as_deref(), Some("vscode")); // parsed 无 source 时兜底
// 空标题同样不覆盖
- let parsed = mk_meta(AgentId::Codex, "codex:file-uuid", "file-uuid", "首条消息推导标题", None);
+ let parsed = mk_meta(
+ AgentId::Codex,
+ "codex:file-uuid",
+ "file-uuid",
+ "首条消息推导标题",
+ None,
+ );
let quick = mk_meta(AgentId::Codex, "codex:thread-1", "thread-1", "", None);
let merged = codex.merge_quick_meta(parsed, &quick);
assert_eq!(merged.title, "首条消息推导标题");
@@ -1280,7 +1528,12 @@ fn with_custom_root_contract() {
let custom = dir.path().join("somewhere-else");
for base in wake_core::adapters::create_adapters() {
let inst = base.with_custom_root(custom.clone());
- assert_eq!(inst.agent(), base.agent(), "{:?}: 自定义实例换了 agent", base.agent());
+ assert_eq!(
+ inst.agent(),
+ base.agent(),
+ "{:?}: 自定义实例换了 agent",
+ base.agent()
+ );
let roots = inst.data_roots();
assert!(!roots.is_empty(), "{:?}: 自定义实例无数据根", base.agent());
for r in &roots {
@@ -1344,9 +1597,15 @@ fn removed_defaults_suppress_instances() {
&[(AgentId::ClaudeCode, dir.path().to_path_buf())],
&[AgentId::ClaudeCode],
);
- let claude: Vec<_> = roster.iter().filter(|a| a.agent() == AgentId::ClaudeCode).collect();
+ let claude: Vec<_> = roster
+ .iter()
+ .filter(|a| a.agent() == AgentId::ClaudeCode)
+ .collect();
assert_eq!(claude.len(), 1, "默认被压制后应只剩自定义实例");
- assert!(claude[0].data_roots().iter().all(|r| r.starts_with(dir.path())));
+ assert!(claude[0]
+ .data_roots()
+ .iter()
+ .all(|r| r.starts_with(dir.path())));
}
/// normalize_custom_root(静态分派,不依赖 roster——该家默认被移除时也要
@@ -1360,9 +1619,16 @@ fn codex_normalize_lifts_sessions_dir_to_home() {
let home = tmp.path().join("codex-home");
fs::create_dir_all(home.join("sessions").join("2026")).unwrap();
fs::create_dir_all(home.join("archived_sessions")).unwrap();
- fs::write(home.join("archived_sessions").join("rollout-x.jsonl"), b"{}").unwrap();
+ fs::write(
+ home.join("archived_sessions").join("rollout-x.jsonl"),
+ b"{}",
+ )
+ .unwrap();
fs::write(home.join("state_5.sqlite"), b"x").unwrap();
- assert_eq!(normalize_custom_root(AgentId::Codex, home.join("sessions")), home);
+ assert_eq!(
+ normalize_custom_root(AgentId::Codex, home.join("sessions")),
+ home
+ );
assert_eq!(
normalize_custom_root(AgentId::Codex, home.join("archived_sessions")),
home,
@@ -1410,7 +1676,9 @@ fn create_adapters_for_honors_store_config() {
setup();
let dir = tempfile::tempdir().unwrap();
let store = wake_core::db::Store::open(&dir.path().join("t.db")).unwrap();
- store.add_custom_root("claude-code", "/tmp/claude-backup").unwrap();
+ store
+ .add_custom_root("claude-code", "/tmp/claude-backup")
+ .unwrap();
store.add_removed_default("codex").unwrap();
let roster = wake_core::adapters::create_adapters_for(&store);
assert!(
@@ -1418,12 +1686,54 @@ fn create_adapters_for_honors_store_config() {
"被移除的预设仍在 roster"
);
assert_eq!(
- roster.iter().filter(|a| a.agent() == AgentId::ClaudeCode).count(),
+ roster
+ .iter()
+ .filter(|a| a.agent() == AgentId::ClaudeCode)
+ .count(),
2,
"自定义 location 未生效"
);
}
+/// location 开关按真实数据根过滤 active roster,但管理快照必须保留停用行。
+/// Codex 的 sessions/archived 来自同一 adapter,验证两行可以独立控制。
+#[test]
+fn disabled_location_stays_configured_but_leaves_active_roster() {
+ setup();
+ let dir = tempfile::tempdir().unwrap();
+ let store = wake_core::db::Store::open(&dir.path().join("t.db")).unwrap();
+ let codex_home = dir.path().join("codex-copy");
+ let sessions = codex_home.join("sessions");
+ let archived = codex_home.join("archived_sessions");
+ fs::create_dir_all(&sessions).unwrap();
+ fs::create_dir_all(&archived).unwrap();
+ store
+ .add_custom_root("codex", codex_home.to_str().unwrap())
+ .unwrap();
+ store
+ .set_location_enabled("codex", sessions.to_str().unwrap(), false)
+ .unwrap();
+
+ let roster = wake_core::adapters::create_adapter_roster_for(&store);
+ assert!(roster.locations.iter().any(|location| {
+ location.agent == AgentId::Codex && location.path == sessions && !location.enabled
+ }));
+ assert!(roster.locations.iter().any(|location| {
+ location.agent == AgentId::Codex && location.path == archived && location.enabled
+ }));
+ let active_roots: Vec<_> = roster
+ .active
+ .iter()
+ .filter(|adapter| adapter.agent() == AgentId::Codex)
+ .flat_map(|adapter| adapter.data_roots())
+ .collect();
+ assert!(!active_roots.contains(&sessions), "停用根仍进入扫描 roster");
+ assert!(
+ active_roots.contains(&archived),
+ "同一 location 的另一根被误关"
+ );
+}
+
/// path_owns 的边界字典:分隔符边界(sessions-old 不属 sessions)、SQLite
/// 虚拟路径的 '#'、文件系统根 "/"(strip_prefix 剥掉的正是分隔符,通用分支
/// 会全判界外——2026-08-24 Codex review)
@@ -1456,10 +1766,19 @@ fn path_owns_windows_shapes() {
// 盘符根以分隔符收尾,一切后代在界内
assert!(path_owns(r"C:\", r"C:\Users\me\x.jsonl"));
// 反斜杠边界与 POSIX 同规
- assert!(path_owns(r"C:\Users\me\.claude", r"C:\Users\me\.claude\p\x.jsonl"));
- assert!(!path_owns(r"C:\Users\me\.claude", r"C:\Users\me\.claude-old\x.jsonl"));
+ assert!(path_owns(
+ r"C:\Users\me\.claude",
+ r"C:\Users\me\.claude\p\x.jsonl"
+ ));
+ assert!(!path_owns(
+ r"C:\Users\me\.claude",
+ r"C:\Users\me\.claude-old\x.jsonl"
+ ));
// SQLite 虚拟路径
- assert!(path_owns(r"C:\Users\me\store.db", r"C:\Users\me\store.db#42"));
+ assert!(path_owns(
+ r"C:\Users\me\store.db",
+ r"C:\Users\me\store.db#42"
+ ));
}
/// 裸 Codex 数据目录按目录名保角色(2026-08-24 Codex review):独立 archived
diff --git a/crates/wake-core/tests/db_roundtrip.rs b/crates/wake-core/tests/db_roundtrip.rs
index fe2b79c..5a2880e 100644
--- a/crates/wake-core/tests/db_roundtrip.rs
+++ b/crates/wake-core/tests/db_roundtrip.rs
@@ -92,7 +92,9 @@ fn user_data_survives_rebuild() {
let (_dir, store) = temp_store();
let m = meta("claude-code:s3", "收藏的会话");
store.write_session(&m, m.updated_at, &[]).unwrap();
- store.set_user_data("claude-code:s3", Some(true), Some(true)).unwrap();
+ store
+ .set_user_data("claude-code:s3", Some(true), Some(true))
+ .unwrap();
// 重建索引(sessions/messages 清空重来)后,收藏/置顶必须还在
store.rebuild_all().unwrap();
@@ -128,7 +130,10 @@ fn list_sessions_filters_and_counts() {
assert_eq!(total, 2);
assert_eq!(sessions[0].key, "claude-code:s4", "默认按 updated 降序");
- let only_codex = SessionFilter { agents: vec![AgentId::Codex], ..all };
+ let only_codex = SessionFilter {
+ agents: vec![AgentId::Codex],
+ ..all
+ };
let (sessions, total) = store.list_sessions(&only_codex).unwrap();
assert_eq!(total, 1);
assert_eq!(sessions[0].key, "codex:s5");
@@ -158,7 +163,10 @@ fn path_counts_respect_agent_and_boundary() {
let counts = store
.counts_by_path_prefix(&[
("claude-code".into(), "/home/u/.claude/projects".into()),
- ("codex".into(), "/home/u/.claude/projects/codex/sessions".into()),
+ (
+ "codex".into(),
+ "/home/u/.claude/projects/codex/sessions".into(),
+ ),
])
.expect("counts");
assert_eq!(counts[0], 1, "codex 的会话不该被记到 claude 行");
@@ -210,7 +218,7 @@ fn custom_roots_roundtrip() {
// 编辑的原子替换:自定义换路径 / 预设改自定义 / 换 agent,全走单事务
store.add_custom_root("grok", "/tmp/g1").unwrap();
store
- .replace_location("grok", Some("/tmp/g1"), None, "grok", "/tmp/g2")
+ .replace_location("grok", Some("/tmp/g1"), None, "/tmp/g1", "grok", "/tmp/g2")
.unwrap();
assert_eq!(
store.list_custom_roots().unwrap(),
@@ -220,7 +228,7 @@ fn custom_roots_roundtrip() {
]
);
store
- .replace_location("kiro", None, None, "kiro", "/tmp/k")
+ .replace_location("kiro", None, None, "/tmp/kiro-default", "kiro", "/tmp/k")
.unwrap();
assert!(store
.list_removed_defaults()
@@ -231,6 +239,7 @@ fn custom_roots_roundtrip() {
"opencode",
None,
Some("/tmp/opencode.db"),
+ "/tmp/opencode.db",
"opencode",
"/tmp/opencode-copy",
)
@@ -240,7 +249,14 @@ fn custom_roots_roundtrip() {
.unwrap()
.contains(&("opencode".to_string(), "/tmp/opencode.db".to_string())));
store
- .replace_location("grok", Some("/tmp/g2"), None, "cursor", "/tmp/cur")
+ .replace_location(
+ "grok",
+ Some("/tmp/g2"),
+ None,
+ "/tmp/g2",
+ "cursor",
+ "/tmp/cur",
+ )
.unwrap();
let roots = store.list_custom_roots().unwrap();
assert!(roots.iter().any(|(a, p)| a == "cursor" && p == "/tmp/cur"));
@@ -254,6 +270,68 @@ fn custom_roots_roundtrip() {
assert!(store.list_removed_default_roots().unwrap().is_empty());
}
+/// location 开关只持久化停用状态,不删除配置;真正 Remove 自定义根或
+/// Restore defaults 时清理相关状态,今后重新添加默认启用。
+#[test]
+fn disabled_locations_roundtrip() {
+ let (_dir, store) = temp_store();
+ store.add_custom_root("codex", "/tmp/codex-copy").unwrap();
+ store
+ .set_location_enabled("codex", "/tmp/codex-copy/sessions", false)
+ .unwrap();
+ store
+ .set_location_enabled("codex", "/tmp/codex-copy/sessions", false)
+ .unwrap(); // 幂等
+ store
+ .set_location_enabled("claude-code", "/tmp/claude", false)
+ .unwrap();
+
+ let mut disabled = store.list_disabled_locations().unwrap();
+ disabled.sort();
+ assert_eq!(
+ disabled,
+ vec![
+ ("claude-code".to_string(), "/tmp/claude".to_string()),
+ ("codex".to_string(), "/tmp/codex-copy/sessions".to_string(),),
+ ]
+ );
+ assert_eq!(store.disabled_locations().len(), 2);
+
+ store
+ .set_location_enabled("claude-code", "/tmp/claude", true)
+ .unwrap();
+ assert_eq!(store.list_disabled_locations().unwrap().len(), 1);
+
+ store
+ .remove_custom_root("codex", "/tmp/codex-copy")
+ .unwrap();
+ assert!(store.list_disabled_locations().unwrap().is_empty());
+
+ store
+ .set_location_enabled("gemini", "/tmp/gemini-default", false)
+ .unwrap();
+ store
+ .replace_location(
+ "gemini",
+ None,
+ None,
+ "/tmp/gemini-default",
+ "gemini",
+ "/tmp/gemini-copy",
+ )
+ .unwrap();
+ assert!(
+ store.list_disabled_locations().unwrap().is_empty(),
+ "编辑停用的内置 location 后遗留了旧状态"
+ );
+
+ store
+ .set_location_enabled("cursor", "/tmp/cursor", false)
+ .unwrap();
+ store.clear_location_overrides().unwrap();
+ assert!(store.list_disabled_locations().unwrap().is_empty());
+}
+
/// 增量写入的胜者裁决在写事务内:败方副本(旧 mtime、异路径)一字不写,
/// 反超后按规则接管(2026-08-24 Codex review)
#[test]
@@ -265,9 +343,21 @@ fn guarded_write_respects_winner() {
let mut loser = meta("codex:g", "败方");
loser.file_path = "/backup/g.jsonl".into();
- assert!(!store.write_session_guarded(&loser, 5, &[]).unwrap(), "败方不该写入");
- assert_eq!(store.get_session("codex:g").unwrap().unwrap().file_path, "/live/g.jsonl");
+ assert!(
+ !store.write_session_guarded(&loser, 5, &[]).unwrap(),
+ "败方不该写入"
+ );
+ assert_eq!(
+ store.get_session("codex:g").unwrap().unwrap().file_path,
+ "/live/g.jsonl"
+ );
- assert!(store.write_session_guarded(&loser, 12, &[]).unwrap(), "反超应接管");
- assert_eq!(store.get_session("codex:g").unwrap().unwrap().file_path, "/backup/g.jsonl");
+ assert!(
+ store.write_session_guarded(&loser, 12, &[]).unwrap(),
+ "反超应接管"
+ );
+ assert_eq!(
+ store.get_session("codex:g").unwrap().unwrap().file_path,
+ "/backup/g.jsonl"
+ );
}
diff --git a/crates/wake/src/workbench.rs b/crates/wake/src/workbench.rs
index edd7aff..c52b195 100644
--- a/crates/wake/src/workbench.rs
+++ b/crates/wake/src/workbench.rs
@@ -31,25 +31,31 @@ use gpui_component::notification::Notification;
use gpui_component::progress::Progress;
use gpui_component::scroll::ScrollableElement as _;
use gpui_component::spinner::Spinner;
+use gpui_component::switch::Switch;
use gpui_component::text::{TextView, TextViewStyle};
use gpui_component::{
- h_flex, v_flex, ActiveTheme as _, Icon, IndexPath, Root, Sizable as _,
- StyledExt as _, TitleBar, WindowExt as _,
+ h_flex, v_flex, ActiveTheme as _, Icon, IndexPath, Root, Sizable as _, StyledExt as _,
+ TitleBar, WindowExt as _,
};
-use wake_core::adapters::{adapter_for, create_adapters_for, path_owns, AgentAdapter};
+use wake_core::adapters::{
+ adapter_for, create_adapter_roster_for, path_owns, AdapterLocation, AgentAdapter,
+};
use wake_core::db::Store;
use wake_core::models::*;
use wake_core::scanner::{run_scan, ScanEvents, ScanProgress};
use wake_core::services::{exporter, terminal};
use wake_core::watcher::{start_watcher, SessionWatcher};
-use crate::ui::*;
use crate::format::{
abs_date, display_file_path, expand_tilde, fmt_tokens, one_line, relative_time, tilde_path,
};
+use crate::ui::*;
-actions!(wake, [ToggleSearch, RefreshSessions, PaletteUp, PaletteDown]);
+actions!(
+ wake,
+ [ToggleSearch, RefreshSessions, PaletteUp, PaletteDown]
+);
pub const KEY_CONTEXT: &str = "Workbench";
/// ⌘K 面板容器的 key context(main.rs 的 ↑↓ 绑定与 dialog 元素共用)
@@ -59,6 +65,9 @@ const PALETTE_HEIGHT: Pixels = px(492.);
/// location 表单标签列宽(Agent/Folder 两行共用)
const FORM_LABEL_W: Pixels = px(52.);
+type SharedAdapters = Arc<Vec<Box<dyn AgentAdapter>>>;
+type SharedLocations = Arc<Vec<AdapterLocation>>;
+
fn icon(path: &'static str) -> Icon {
Icon::empty().path(path)
}
@@ -66,7 +75,7 @@ fn icon(path: &'static str) -> Icon {
/// 起一条后台扫描线程。启动时的自动扫描(full=false)与用户主动重扫(full=true)
/// 共用;返回的 Result 由 run_scan 的终态事件代为上报,这里只需丢弃。
fn spawn_scan(
- adapters: Arc<Vec<Box<dyn AgentAdapter>>>,
+ adapters: SharedAdapters,
store: Arc<Store>,
events: Arc<dyn ScanEvents>,
full: bool,
@@ -117,51 +126,62 @@ impl ListDelegate for SessionsDelegate {
let theme = cx.theme();
Some(
- ListItem::new(ix.row).rounded(theme.radius).mx(SPACE_SM).child(
- v_flex()
- .w_full()
- .px(SPACE_XS)
- .py(SPACE_SM)
- .gap(SPACE_XS)
- .child(
- h_flex()
- .gap(px(6.))
- .child(
- div()
- .flex_1()
- .min_w_0()
- .text_size(FONT_BODY)
- .font_medium()
- .text_color(theme.foreground)
- .truncate()
- .child(s.title.clone()),
- )
- .when(s.pinned, |this| {
- this.child(
- icon("icons/pin-filled.svg")
- .with_size(px(11.))
- .text_color(theme.primary),
+ ListItem::new(ix.row)
+ .rounded(theme.radius)
+ .mx(SPACE_SM)
+ .child(
+ v_flex()
+ .w_full()
+ .px(SPACE_XS)
+ .py(SPACE_SM)
+ .gap(SPACE_XS)
+ .child(
+ h_flex()
+ .gap(px(6.))
+ .child(
+ div()
+ .flex_1()
+ .min_w_0()
+ .text_size(FONT_BODY)
+ .font_medium()
+ .text_color(theme.foreground)
+ .truncate()
+ .child(s.title.clone()),
)
- })
- .when(s.favorite, |this| {
- this.child(
- icon("icons/star-filled.svg")
- .with_size(px(11.))
- .text_color(rgb(crate::theme::STAR_YELLOW)),
+ .when(s.pinned, |this| {
+ this.child(
+ icon("icons/pin-filled.svg")
+ .with_size(px(11.))
+ .text_color(theme.primary),
+ )
+ })
+ .when(s.favorite, |this| {
+ this.child(
+ icon("icons/star-filled.svg")
+ .with_size(px(11.))
+ .text_color(rgb(crate::theme::STAR_YELLOW)),
+ )
+ }),
+ )
+ .child(
+ h_flex()
+ .gap(px(6.))
+ .text_size(FONT_LABEL)
+ .text_color(theme.muted_foreground)
+ .child(
+ img(s.agent.brand_icon(theme.mode.is_dark()))
+ .size(px(15.))
+ .flex_shrink_0(),
)
- }),
- )
- .child(
- h_flex()
- .gap(px(6.))
- .text_size(FONT_LABEL)
- .text_color(theme.muted_foreground)
- .child(img(s.agent.brand_icon(theme.mode.is_dark())).size(px(15.)).flex_shrink_0())
- .child(badge(s.project_name.clone(), theme.muted, theme.muted_foreground))
- .child(div().flex_1())
- .child(div().flex_shrink_0().child(relative_time(s.updated_at))),
- ),
- ),
+ .child(badge(
+ s.project_name.clone(),
+ theme.muted,
+ theme.muted_foreground,
+ ))
+ .child(div().flex_1())
+ .child(div().flex_shrink_0().child(relative_time(s.updated_at))),
+ ),
+ ),
)
}
@@ -217,7 +237,11 @@ impl ListDelegate for SearchDelegate {
h_flex()
.gap(SPACE_SM)
.text_size(FONT_CAPTION)
- .child(img(h.session.agent.brand_icon(theme.mode.is_dark())).size(px(15.)).flex_shrink_0())
+ .child(
+ img(h.session.agent.brand_icon(theme.mode.is_dark()))
+ .size(px(15.))
+ .flex_shrink_0(),
+ )
.child(
div()
.min_w_0()
@@ -271,7 +295,9 @@ impl ListDelegate for SearchDelegate {
if q.trim().is_empty() {
(Vec::new(), false)
} else {
- store.search(&q, &[], None, 60).unwrap_or((Vec::new(), false))
+ store
+ .search(&q, &[], None, 60)
+ .unwrap_or((Vec::new(), false))
}
});
cx.spawn_in(window, async move |this, cx| {
@@ -369,7 +395,10 @@ struct DetailState {
pub struct Workbench {
focus_handle: FocusHandle,
store: Arc<Store>,
- adapters: Arc<Vec<Box<dyn AgentAdapter>>>,
+ /// 扫描/监听只含启用 location;管理面板另读 data_locations,停用行不消失。
+ adapters: SharedAdapters,
+ /// 与 adapters 同一次 roster 构造得到的全部 location 路径快照。
+ data_locations: SharedLocations,
selected_agent: Option<AgentId>,
selected_project: Option<String>,
@@ -438,10 +467,19 @@ struct DataSourceRow {
custom: Option<SharedString>,
/// 预设行是否能只压制本路径,而不关闭该 agent 的整个默认实例。
individual_default: bool,
+ /// Rc<Cell> 让开关成功后原位刷新;dialog builder 捕获的是静态行快照,
+ /// 不能在 render 中反读 Workbench(会触发 double-lease)。
+ enabled: Rc<Cell<bool>>,
+}
+
+#[derive(Clone)]
+struct LocationToggleState {
+ enabled: Rc<Cell<bool>>,
+ diverged: Rc<Cell<bool>>,
}
-/// location 表单的语义目标。预设行的"编辑/删除"落库为**压制默认 + 记自定义**;
-/// 多产品库可按真实 root 单独压制,其余 adapter 仍按整家默认实例处理。
+/// location 表单的语义目标。预设行的“编辑”落库为**压制默认 + 记自定义**;
+/// 真正的 Remove 只对自定义 location 出现,预设行由开关启停。
#[derive(Clone)]
enum FormTarget {
Add,
@@ -473,7 +511,7 @@ impl Workbench {
}
};
let store = Arc::new(store);
- let adapters = Self::build_roster(&store);
+ let (adapters, data_locations) = Self::build_roster(&store);
let list_state = cx.new(|cx| {
ListState::new(
@@ -531,6 +569,7 @@ impl Workbench {
focus_handle: cx.focus_handle(),
store,
adapters,
+ data_locations,
selected_agent: None,
selected_project: None,
sort_key: SortKey::Updated,
@@ -575,7 +614,10 @@ impl Workbench {
// 终端应用图标后台提取(首次数百 ms,之后命中缓存)
let icons_task = cx.background_spawn(async {
- let dir = dirs::data_dir().unwrap_or_default().join("wake").join("app-icons");
+ let dir = dirs::data_dir()
+ .unwrap_or_default()
+ .join("wake")
+ .join("app-icons");
terminal::ensure_app_icons(&dir)
});
cx.spawn_in(window, async move |this, cx| {
@@ -671,16 +713,13 @@ impl Workbench {
v_flex()
.gap(SPACE_LG)
.child(
- h_flex()
- .gap(SPACE_SM)
- .child(Spinner::new().small())
- .child(
- div()
- .text_size(FONT_HEADING)
- .font_semibold()
- .text_color(theme.foreground)
- .child("Refreshing sessions"),
- ),
+ h_flex().gap(SPACE_SM).child(Spinner::new().small()).child(
+ div()
+ .text_size(FONT_HEADING)
+ .font_semibold()
+ .text_color(theme.foreground)
+ .child("Refreshing sessions"),
+ ),
)
.child(Progress::new().value(pct))
.child(
@@ -695,39 +734,31 @@ impl Workbench {
/// "Wake 读哪些路径"面板(侧栏底部数据源钮)。列全十三家含本机没装的,
/// 呼应"只读你的目录、零网络"的产品承诺;行点击即编辑,底部 Add location
- /// 打开增改删共用的表单。数据在打开前一次算好
+ /// 打开增改共用的表单。数据在打开前一次算好
/// move 进闭包——dialog builder 在宿主 render 期间执行,闭包内 read 宿主
/// entity 必 double-lease panic
fn show_data_sources(&mut self, window: &mut Window, cx: &mut Context<Self>) {
- // 数据源**必须**读 self.adapters——与 scanner/watcher/refresh 同一份
- // 实例。根路径是构造时刻对 env(CODEX_HOME/XDG_DATA_HOME)与文件系统
- // 的快照,二次构造(旧 all_data_sources 的做法)可能解析出不同的根,
- // 面板就会展示一个本次会话根本不会读的路径——连着几轮 review 修的
- // 都是这一个根因的不同投影;同一份实例下不一致没有存在空间。
- // 先摊平成"一路径一行",prefixes 与各行由**同一份** flat 派生:两次
- // 独立 flat_map 再按位置 zip 计数,靠的是遍历顺序一致这条隐形契约。
+ // 数据源必须读 data_locations——它与 scanner/watcher 的 active roster
+ // 由同一批 adapter 实例派生,既保留停用行,又避免二次构造时 env
+ // (CODEX_HOME/XDG_DATA_HOME)或文件系统探测产生不同根路径快照。
+ // prefixes 与各行由同一份 flat 派生,计数与显示不会错位。
// 文本一律预先算成 SharedString:dialog builder 存的是 Rc<dyn Fn>,
// 面板开着时每帧重跑,留 format!/String::clone 在里面就是每帧堆分配
- let mut flat: Vec<(AgentId, PathBuf, bool)> = self
- .adapters
- .iter()
- .flat_map(|a| {
- let agent = a.agent();
- let individual = a.supports_individual_root_removal();
- a.data_roots()
- .into_iter()
- .map(move |r| (agent, r, individual))
- })
- .collect();
+ let mut flat = self.data_locations.as_ref().clone();
// 按 AgentId 声明序稳定排序:自定义根紧随该家默认根之后成组展示
// (roster 里 customs 追加在尾部,不排会飘到列表底部与所属家分离);
// 稳定排序保证同家内默认在前、codex 的 sessions/archived 相邻不散
- flat.sort_by_key(|(a, _, _)| *a);
+ flat.sort_by_key(|location| location.agent);
// 带上 agent:计数按 (agent, 根) 归属,不然一家的根被 env 搬进另一家
// 树下时,会话会整批记到别家行上
let prefixes: Vec<(String, String)> = flat
.iter()
- .map(|(a, r, _)| (a.as_str().to_string(), r.to_string_lossy().to_string()))
+ .map(|location| {
+ (
+ location.agent.as_str().to_string(),
+ location.path.to_string_lossy().to_string(),
+ )
+ })
.collect();
let counts = self
.store
@@ -743,15 +774,15 @@ impl Workbench {
.iter()
.zip(prefixes)
.zip(counts)
- .map(|(((agent, root, individual_default), (_, raw)), n)| {
+ .map(|((location, (_, raw)), n)| {
// 存在性逐路径判断:某家的归档目录可能还没建,不该按整家一刀切
- let exists = root.exists();
+ let exists = location.path.exists();
// 本行根落在同家某个自定义 location 之下 → 可移除行。
// 携带**落库路径**而非本行根:codex 一个自定义家目录派生
// sessions/archived 两行,删除按落库那条删
- let custom = custom_owner(&customs, *agent, &raw).cloned();
+ let custom = custom_owner(&customs, location.agent, &raw).cloned();
DataSourceRow {
- agent: *agent,
+ agent: location.agent,
display: tilde_path(&raw).into(),
raw: raw.into(),
tally: if exists {
@@ -761,12 +792,19 @@ impl Workbench {
},
exists,
custom,
- individual_default: *individual_default,
+ individual_default: location.individually_removable,
+ enabled: Rc::new(Cell::new(location.enabled)),
}
})
.collect();
- // 有任何偏离(自定义或被移除的预设)才给 Restore defaults 出场
- let diverged = !customs.is_empty() || !removed.is_empty() || !removed_roots.is_empty();
+ // 有任何偏离(自定义、被移除的预设或停用项)才给 Restore defaults 出场;
+ // 开关与 footer 共享 Cell,面板无需关闭重开即可同步显隐。
+ let diverged = Rc::new(Cell::new(
+ !customs.is_empty()
+ || !removed.is_empty()
+ || !removed_roots.is_empty()
+ || self.data_locations.iter().any(|location| !location.enabled),
+ ));
let entity = cx.entity();
window.open_dialog(cx, move |dialog, _window, cx| {
let theme = cx.theme();
@@ -802,7 +840,9 @@ impl Workbench {
if std::path::Path::new(raw).is_file() {
std::path::Path::new(raw)
.parent()
- .map(|p| SharedString::from(p.to_string_lossy().to_string()))
+ .map(|p| {
+ SharedString::from(p.to_string_lossy().to_string())
+ })
.unwrap_or_else(|| row.raw.clone())
} else {
row.raw.clone()
@@ -816,6 +856,13 @@ impl Workbench {
individual_default: row.individual_default,
};
let edit_entity = entity.clone();
+ let toggle_entity = entity.clone();
+ let toggle_state = LocationToggleState {
+ enabled: row.enabled.clone(),
+ diverged: diverged.clone(),
+ };
+ let toggle_agent = row.agent;
+ let toggle_path = row.raw.clone();
h_flex()
.id(("data-source-row", ix))
.h(ROW_HEIGHT_SUB)
@@ -858,24 +905,56 @@ impl Workbench {
.child(row.display.clone()),
)
.child(
- // 尾列纯计数 badge:悬停工具试过、用户否决
- // (2026-08-24,Finder/移除挪进编辑表单)
+ // 停用时以状态替代已过期计数;重新开启后的
+ // 增量扫描会恢复真值,下次打开面板即更新。
h_flex()
.w(px(88.))
.flex_shrink_0()
.justify_end()
.text_size(FONT_LABEL)
.child({
- // 有目录取中性灰(同项目名 badge);目录不在
- // 取 warning 淡底 tint——这是"本机没这家"的
- // 陈述而非报错,不用实心告警色。文字实色,
- // 只有底叠 opacity
- let (bg, fg) = if row.exists {
- (theme.muted, theme.muted_foreground)
+ if !row.enabled.get() {
+ badge(
+ SharedString::from("Disabled"),
+ theme.muted,
+ theme.muted_foreground,
+ )
} else {
- (theme.warning.opacity(0.14), theme.warning)
- };
- badge(row.tally.clone(), bg, fg)
+ // 有目录取中性灰(同项目名 badge);目录不在
+ // 取 warning 淡底 tint——这是"本机没这家"的
+ // 陈述而非报错,不用实心告警色。文字实色,
+ // 只有底叠 opacity
+ let (bg, fg) = if row.exists {
+ (theme.muted, theme.muted_foreground)
+ } else {
+ (theme.warning.opacity(0.14), theme.warning)
+ };
+ badge(row.tally.clone(), bg, fg)
+ }
+ }),
+ )
+ .child(
+ Switch::new(("data-source-enabled", ix))
+ .checked(row.enabled.get())
+ .small()
+ .tooltip(if row.enabled.get() {
+ "Disable location"
+ } else {
+ "Enable location"
+ })
+ .on_click(move |enabled, window, cx| {
+ let state = toggle_state.clone();
+ let path = toggle_path.clone();
+ toggle_entity.update(cx, |this, cx| {
+ this.set_location_enabled(
+ toggle_agent,
+ path,
+ *enabled,
+ state.clone(),
+ window,
+ cx,
+ )
+ });
}),
)
})),
@@ -910,10 +989,12 @@ impl Workbench {
});
}
})
- .child(icon("icons/plus.svg").with_size(px(14.)).flex_shrink_0())
+ .child(
+ icon("icons/plus.svg").with_size(px(14.)).flex_shrink_0(),
+ )
.child(div().text_size(FONT_CAPTION).child("Add location")),
)
- .when(diverged, |el| {
+ .when(diverged.get(), |el| {
el.child(
// 恢复初始:清空全部偏离,回到内置默认路径
h_flex()
@@ -934,7 +1015,9 @@ impl Workbench {
});
}
})
- .child(div().text_size(FONT_CAPTION).child("Restore defaults")),
+ .child(
+ div().text_size(FONT_CAPTION).child("Restore defaults"),
+ ),
)
}),
),
@@ -942,10 +1025,11 @@ impl Workbench {
});
}
- /// store 的 location 配置 → roster。new 与 rebuild_roster 共用;解析与
- /// 组装都在 wake-core(create_adapters_for),与 scan CLI 同一条路
- fn build_roster(store: &Arc<Store>) -> Arc<Vec<Box<dyn AgentAdapter>>> {
- Arc::new(create_adapters_for(store))
+ /// store 的 location 配置 → active roster + 全量路径快照。new 与
+ /// rebuild_roster 共用;解析与组装都在 wake-core,与 scan CLI 同一条路。
+ fn build_roster(store: &Arc<Store>) -> (SharedAdapters, SharedLocations) {
+ let roster = create_adapter_roster_for(store);
+ (Arc::new(roster.active), Arc::new(roster.locations))
}
/// location 配置变更后的唯一 roster 换代点:同一处换 Arc + 重启 watcher,
@@ -955,15 +1039,24 @@ impl Workbench {
// 先撤旧 watcher 并等它退出(SessionWatcher::Drop 内 join):旧线程持
// 旧 roster,不等收尾,已移除根的会话可能在补扫后被写回复活
self.watcher = None;
- self.adapters = Self::build_roster(&self.store);
- self.watcher = start_watcher(self.adapters.clone(), self.store.clone(), self.scan_events.clone());
+ (self.adapters, self.data_locations) = Self::build_roster(&self.store);
+ self.watcher = start_watcher(
+ self.adapters.clone(),
+ self.store.clone(),
+ self.scan_events.clone(),
+ );
cx.notify();
}
/// location 表单(添加/编辑共用一套 UI,2026-08-24 定稿):agent 下拉 +
/// 路径输入框(可手输,~ 展开)+ 目录选择按钮;Cancel/Save 只在有改动时
/// 出现。压栈在面板之上,esc/取消原生弹回
- fn open_location_form(&mut self, target: FormTarget, window: &mut Window, cx: &mut Context<Self>) {
+ fn open_location_form(
+ &mut self,
+ target: FormTarget,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
let (title, ok_label, init_agent, init_path): (
&'static str,
&'static str,
@@ -1144,94 +1237,93 @@ impl Workbench {
let FormTarget::Edit {
agent,
path,
- root,
+ root: _,
custom,
- individual_default,
+ individual_default: _,
} = action_target.clone()
else {
unreachable!("edit_exists 仅在 Edit 目标下为 Some")
};
let remove_entity = entity.clone();
- el.child(
- // 动作行遵循破坏性靠左惯例:Remove 靠左、Show in
- // Finder 靠右。两钮手排:内边距 = 轴缩进,Remove
- // 左侧再减 1.5 补 lucide 字形内白(24 视框留 3
- // 单位),字形左缘正落标签轴;右钮文字右缘正落
- // 浏览钮右缘。全正值内边距,胶囊完整在内容盒里
- h_flex()
- .pt(SPACE_XS)
- .items_center()
- .justify_between()
- .child(
- h_flex()
- .id("loc-remove")
- .h(BUTTON_SM_H)
- .pl(BUTTON_SM_PX - px(1.5))
- .pr(BUTTON_SM_PX)
- .rounded(RADIUS_BUTTON)
- .items_center()
- .gap(px(6.))
- .cursor_pointer()
- .text_size(FONT_BODY)
- .text_color(theme.danger)
- .hover(|s| s.bg(theme.danger.opacity(0.1)))
- .active(|s| s.bg(theme.danger.opacity(0.16)))
- .on_click({
- let remove_entity = remove_entity.clone();
- let stored = custom.then(|| path.clone());
- let default_root = (!custom && individual_default)
- .then(|| root.clone());
- move |_, window, cx| {
- // 整栈收场(表单+过期面板);
- // delete 内会重开新快照面板
- window.close_all_dialogs(cx);
- let stored = stored.clone();
- let default_root = default_root.clone();
- remove_entity.update(cx, |this, cx| {
- this.delete_location(
- agent,
- stored,
- default_root,
- window,
- cx,
- )
- });
- }
- })
- .child(
- icon("icons/trash-2.svg")
- .with_size(px(13.))
- .flex_shrink_0(),
+ el.when(custom || exists, |el| {
+ el.child(
+ // 动作行遵循破坏性靠左惯例:Remove 靠左、Show in
+ // Finder 靠右。Remove 只属于真正可删除的自定义
+ // location;内置 location 由行内开关停用,不删除。
+ // 两钮手排:内边距 = 轴缩进,Remove
+ // 左侧再减 1.5 补 lucide 字形内白(24 视框留 3
+ // 单位),字形左缘正落标签轴;右钮文字右缘正落
+ // 浏览钮右缘。全正值内边距,胶囊完整在内容盒里
+ h_flex()
+ .pt(SPACE_XS)
+ .items_center()
+ .justify_between()
+ .when(custom, |el| {
+ el.child(
+ h_flex()
+ .id("loc-remove")
+ .h(BUTTON_SM_H)
+ .pl(BUTTON_SM_PX - px(1.5))
+ .pr(BUTTON_SM_PX)
+ .rounded(RADIUS_BUTTON)
+ .items_center()
+ .gap(px(6.))
+ .cursor_pointer()
+ .text_size(FONT_BODY)
+ .text_color(theme.danger)
+ .hover(|s| s.bg(theme.danger.opacity(0.1)))
+ .active(|s| s.bg(theme.danger.opacity(0.16)))
+ .on_click({
+ let remove_entity = remove_entity.clone();
+ let stored = path.clone();
+ move |_, window, cx| {
+ // 整栈收场(表单+过期面板);
+ // delete 内会重开新快照面板
+ window.close_all_dialogs(cx);
+ let stored = stored.clone();
+ remove_entity.update(cx, |this, cx| {
+ this.delete_location(
+ agent, stored, window, cx,
+ )
+ });
+ }
+ })
+ .child(
+ icon("icons/trash-2.svg")
+ .with_size(px(13.))
+ .flex_shrink_0(),
+ )
+ .child("Remove"),
)
- .child("Remove"),
- )
- .when(exists, |el| {
- el.child(
- h_flex()
- .id("loc-reveal")
- .h(BUTTON_SM_H)
- .px(BUTTON_SM_PX)
- .rounded(RADIUS_BUTTON)
- .items_center()
- .gap(px(6.))
- .cursor_pointer()
- .text_size(FONT_BODY)
- .text_color(theme.foreground)
- .hover(|s| s.bg(theme.secondary_hover))
- .active(|s| s.bg(theme.secondary_active))
- .on_click(move |_, _, _| {
- terminal::open_in_file_manager(&path)
- })
- .child(
- icon("icons/folder.svg")
- .with_size(px(13.))
- .flex_shrink_0()
- .text_color(theme.muted_foreground),
- )
- .child(SHOW_IN_FM),
- )
- }),
- )
+ })
+ .when(exists, |el| {
+ el.child(
+ h_flex()
+ .id("loc-reveal")
+ .h(BUTTON_SM_H)
+ .px(BUTTON_SM_PX)
+ .rounded(RADIUS_BUTTON)
+ .items_center()
+ .gap(px(6.))
+ .cursor_pointer()
+ .text_size(FONT_BODY)
+ .text_color(theme.foreground)
+ .hover(|s| s.bg(theme.secondary_hover))
+ .active(|s| s.bg(theme.secondary_active))
+ .on_click(move |_, _, _| {
+ terminal::open_in_file_manager(&path)
+ })
+ .child(
+ icon("icons/folder.svg")
+ .with_size(px(13.))
+ .flex_shrink_0()
+ .text_color(theme.muted_foreground),
+ )
+ .child(SHOW_IN_FM),
+ )
+ }),
+ )
+ })
}),
)
.on_ok(move |_, window, cx| {
@@ -1324,12 +1416,10 @@ impl Workbench {
// 各家归一化(codex:直选 sessions 树/平铺 archived 上提到家层,侧档
// 找回)。静态分派,不依赖该家实例是否还在 roster(默认被移除时也要
// 生效);归一化后再做无改动/重叠判定,选中默认根数据子目录会正确判"已覆盖"
- let path = wake_core::adapters::normalize_custom_root(
- agent_new,
- std::path::PathBuf::from(&path),
- )
- .to_string_lossy()
- .to_string();
+ let path =
+ wake_core::adapters::normalize_custom_root(agent_new, std::path::PathBuf::from(&path))
+ .to_string_lossy()
+ .to_string();
// 没改就没事:直接让机制关表单,面板未过期。旧目标也要**同规归一化**
// 再比——默认 Codex 的 sessions/archived 行原路径归一化后即 home,不归一
// 化就比,单按 Enter 会被误判成编辑、静默把默认改成"压默认+记自定义"
@@ -1360,12 +1450,11 @@ impl Workbench {
.map(|(a, p)| (a, SharedString::from(p.to_string_lossy().to_string())))
.collect();
let covered = self
- .adapters
+ .data_locations
.iter()
- .filter(|a| a.agent() == agent_new)
- .flat_map(|a| a.data_roots())
- .any(|r| {
- let rs = r.to_string_lossy().to_string();
+ .filter(|location| location.agent == agent_new)
+ .any(|location| {
+ let rs = location.path.to_string_lossy().to_string();
let excluded = match &target {
FormTarget::Add => false,
FormTarget::Edit {
@@ -1410,6 +1499,7 @@ impl Workbench {
agent.as_str(),
custom.then(|| old.as_ref()),
(!custom && *individual_default).then(|| root.as_ref()),
+ root.as_ref(),
agent_new.as_str(),
&path,
),
@@ -1429,22 +1519,18 @@ impl Workbench {
false
}
- /// 删除一个 location(编辑表单内的 Remove):自定义 = 删记录;普通预设 =
- /// 压制该家默认实例;OpenCode stable/next 预设则只压制被点中的库。
- /// 磁盘文件不动,根下会话按"不在枚举范围"出清,收藏/置顶独立留存
+ /// 真正删除一个自定义 location。内置 location 不提供 Remove,只能用
+ /// 行内开关暂时停用;磁盘文件始终不动。
fn delete_location(
&mut self,
agent: AgentId,
- custom: Option<SharedString>,
- default_root: Option<SharedString>,
+ stored: SharedString,
window: &mut Window,
cx: &mut Context<Self>,
) {
- let res = match (&custom, &default_root) {
- (Some(stored), _) => self.store.remove_custom_root(agent.as_str(), stored),
- (None, Some(root)) => self.store.add_removed_default_root(agent.as_str(), root),
- (None, None) => self.store.add_removed_default(agent.as_str()),
- };
+ let res = self
+ .store
+ .remove_custom_root(agent.as_str(), stored.as_ref());
self.apply_location_change(
res,
"Remove failed",
@@ -1454,7 +1540,8 @@ impl Workbench {
);
}
- /// Restore defaults:清空全部偏离(自定义 + 被移除的预设),回到内置默认
+ /// Restore defaults:清空全部偏离(自定义、被移除的预设与停用状态),
+ /// 回到全部启用的内置默认 location。
fn restore_default_locations(&mut self, window: &mut Window, cx: &mut Context<Self>) {
let res = self.store.clear_location_overrides();
self.apply_location_change(
@@ -1466,6 +1553,49 @@ impl Workbench {
);
}
+ /// Session locations 行内开关。状态先落库,再整体换 active roster 与 watcher;
+ /// 当前面板通过共享 Cell 原位反映行状态与 Restore defaults,配置行始终保留。
+ fn set_location_enabled(
+ &mut self,
+ agent: AgentId,
+ path: SharedString,
+ enabled: bool,
+ state: LocationToggleState,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ match self
+ .store
+ .set_location_enabled(agent.as_str(), path.as_ref(), enabled)
+ {
+ Err(e) => window.push_notification(
+ Notification::error(format!("Couldn't update location: {e}")),
+ cx,
+ ),
+ Ok(()) => {
+ state.enabled.set(enabled);
+ self.rebuild_roster(cx);
+ let (customs, removed, removed_roots) = self.store.location_overrides();
+ state.diverged.set(
+ !customs.is_empty()
+ || !removed.is_empty()
+ || !removed_roots.is_empty()
+ || self.data_locations.iter().any(|location| !location.enabled),
+ );
+ self.kick_incremental_scan(cx);
+ window.push_notification(
+ Notification::info(if enabled {
+ "Location enabled"
+ } else {
+ "Location disabled"
+ }),
+ cx,
+ );
+ window.refresh();
+ }
+ }
+ }
+
/// location 变更的统一收尾(删/恢复/表单提交成功共用):失败提示后立即回
/// 面板;成功则 roster 换代 + 补增量 + 提示,面板等补扫终态再重开(此时
/// 计数才是真值)——第四个变更入口出现时,收尾步骤只在这里长
@@ -1590,12 +1720,7 @@ impl Workbench {
}
}
- pub fn toggle_search(
- &mut self,
- _: &ToggleSearch,
- window: &mut Window,
- cx: &mut Context<Self>,
- ) {
+ pub fn toggle_search(&mut self, _: &ToggleSearch, window: &mut Window, cx: &mut Context<Self>) {
if self.refreshing {
return;
}
@@ -1623,12 +1748,18 @@ impl Workbench {
// ↑↓ 在 Input 内不被消费,冒泡到这里走 main.rs 的
// PALETTE_CONTEXT 键位(Input 拆出 List 后原生 List 绑定够不着)
.key_context(PALETTE_CONTEXT)
- .on_action(window.listener_for(&this, |wb: &mut Self, _: &PaletteUp, window, cx| {
- wb.palette_move(-1, window, cx)
- }))
- .on_action(window.listener_for(&this, |wb: &mut Self, _: &PaletteDown, window, cx| {
- wb.palette_move(1, window, cx)
- }))
+ .on_action(window.listener_for(
+ &this,
+ |wb: &mut Self, _: &PaletteUp, window, cx| {
+ wb.palette_move(-1, window, cx)
+ },
+ ))
+ .on_action(window.listener_for(
+ &this,
+ |wb: &mut Self, _: &PaletteDown, window, cx| {
+ wb.palette_move(1, window, cx)
+ },
+ ))
// 定高 + 列表 flex_1:输入行/footer 尺寸变化时列表自适应,
// 不用手工重算列表高度
.h(PALETTE_HEIGHT)
@@ -1762,11 +1893,7 @@ impl Workbench {
this.update_in(cx, |this, window, cx| {
this.palette_list.update(cx, |state, cx| {
let has_hits = !state.delegate().hits.is_empty();
- state.set_selected_index(
- has_hits.then(IndexPath::default),
- window,
- cx,
- );
+ state.set_selected_index(has_hits.then(IndexPath::default), window, cx);
// scroll_to_item 自带 notify,列表随之重绘
state.scroll_to_item(
IndexPath::default(),
@@ -1815,10 +1942,7 @@ impl Workbench {
if n == 0 {
return;
}
- let cur = state
- .selected_index()
- .map(|ix| ix.row as i64)
- .unwrap_or(-1);
+ let cur = state.selected_index().map(|ix| ix.row as i64).unwrap_or(-1);
let next = (cur + delta).clamp(0, n - 1) as usize;
state.set_selected_index(Some(IndexPath::new(next)), window, cx);
// scroll_to_selected_item 内部 notify,选中高亮随之重绘
@@ -1880,8 +2004,11 @@ impl Workbench {
if let Some(detail) = &mut this.detail {
match result {
Some((key, messages)) if key == detail.meta.key => {
- detail.msg_list =
- gpui::ListState::new(messages.len(), gpui::ListAlignment::Bottom, px(512.));
+ detail.msg_list = gpui::ListState::new(
+ messages.len(),
+ gpui::ListAlignment::Bottom,
+ px(512.),
+ );
// 搜索跳转:seq → 可见消息下标,滚到视口顶。
// FTS 命中的行可能被详情过滤(如空文本),用 >= 落到
// 其后最近一条;找不到(尾部被滤)则保持默认落底。
@@ -2063,8 +2190,9 @@ impl Workbench {
// 立刻把它从列表摘掉,不等 watcher 那 800ms 去抖
this.refresh(window, cx);
}
- Err(e) => window
- .push_notification(Notification::error(format!("Delete failed: {e}")), cx),
+ Err(e) => {
+ window.push_notification(Notification::error(format!("Delete failed: {e}")), cx)
+ }
})
.ok();
})
@@ -2160,9 +2288,8 @@ impl Workbench {
fn render_sidebar(&self, window: &Window, cx: &Context<Self>) -> impl IntoElement {
let theme = cx.theme();
- let all_active = self.selected_agent.is_none()
- && self.selected_project.is_none()
- && !self.favorite_only;
+ let all_active =
+ self.selected_agent.is_none() && self.selected_project.is_none() && !self.favorite_only;
// 常态沉默,仅刷新中/监听失效时出现;None 时状态栏整行不渲染。
// 文案在此按 scan 现算,不另存字段——存下来就会有第二个写入点要维护
let note = if self.scan.scanning {
@@ -2171,7 +2298,10 @@ impl Workbench {
total => format!("Refreshing {}/{}", self.scan.done, total),
})
} else {
- self.scan.error.as_ref().map(|e| format!("Refresh failed: {e}"))
+ self.scan
+ .error
+ .as_ref()
+ .map(|e| format!("Refresh failed: {e}"))
};
let status: Option<AnyElement> = if let Some(note) = note {
Some(
@@ -2179,7 +2309,11 @@ impl Workbench {
.w_full()
.gap(SPACE_SM)
.text_color(theme.muted_foreground)
- .child(icon("icons/refresh-cw.svg").with_size(px(12.)).flex_shrink_0())
+ .child(
+ icon("icons/refresh-cw.svg")
+ .with_size(px(12.))
+ .flex_shrink_0(),
+ )
.child(div().min_w_0().truncate().child(note))
.into_any_element(),
)
@@ -2189,7 +2323,13 @@ impl Workbench {
.w_full()
.gap(SPACE_SM)
.text_color(theme.muted_foreground)
- .child(div().size(px(7.)).rounded_full().flex_shrink_0().bg(theme.warning))
+ .child(
+ div()
+ .size(px(7.))
+ .rounded_full()
+ .flex_shrink_0()
+ .bg(theme.warning),
+ )
.child(div().min_w_0().truncate().child("Live updates off"))
.into_any_element(),
)
@@ -2231,49 +2371,41 @@ impl Workbench {
)
.child(
div().flex_shrink_0().px(SIDEBAR_EDGE).pb(SPACE_MD).child(
- h_flex()
- .gap(SPACE_SM)
- .child(
- h_flex()
- .id("sidebar-search")
- .flex_1()
- .min_w_0()
- .h(ROW_HEIGHT)
- .px(SIDEBAR_EDGE)
- .gap(SPACE_SM)
- .rounded(theme.radius)
- .cursor_pointer()
- .bg(theme.secondary)
- .text_size(FONT_CAPTION)
- .text_color(theme.muted_foreground)
- .hover(|s| {
- s.bg(theme.secondary_hover)
- .text_colored(theme.foreground, FONT_CAPTION)
- })
- .active(|s| {
- s.bg(theme.secondary_active)
- .text_colored(theme.foreground, FONT_CAPTION)
- })
- .on_click(cx.listener(|this, _, window, cx| {
- this.toggle_search(&ToggleSearch, window, cx)
- }))
- .child(
- icon("icons/search.svg")
- .with_size(px(13.))
- .flex_shrink_0(),
- )
- // flex_1 + min_w_0 + truncate:空间不足时压这里,
- // 绝不把右侧刷新按钮挤出侧栏
- .child(
- div().flex_1().min_w_0().truncate().child("Search sessions"),
- )
- .child(
- div()
- .flex_shrink_0()
- .text_size(FONT_LABEL)
- .child(search_key_hint()),
- ),
- )
+ h_flex().gap(SPACE_SM).child(
+ h_flex()
+ .id("sidebar-search")
+ .flex_1()
+ .min_w_0()
+ .h(ROW_HEIGHT)
+ .px(SIDEBAR_EDGE)
+ .gap(SPACE_SM)
+ .rounded(theme.radius)
+ .cursor_pointer()
+ .bg(theme.secondary)
+ .text_size(FONT_CAPTION)
+ .text_color(theme.muted_foreground)
+ .hover(|s| {
+ s.bg(theme.secondary_hover)
+ .text_colored(theme.foreground, FONT_CAPTION)
+ })
+ .active(|s| {
+ s.bg(theme.secondary_active)
+ .text_colored(theme.foreground, FONT_CAPTION)
+ })
+ .on_click(cx.listener(|this, _, window, cx| {
+ this.toggle_search(&ToggleSearch, window, cx)
+ }))
+ .child(icon("icons/search.svg").with_size(px(13.)).flex_shrink_0())
+ // flex_1 + min_w_0 + truncate:空间不足时压这里,
+ // 绝不把右侧刷新按钮挤出侧栏
+ .child(div().flex_1().min_w_0().truncate().child("Search sessions"))
+ .child(
+ div()
+ .flex_shrink_0()
+ .text_size(FONT_LABEL)
+ .child(search_key_hint()),
+ ),
+ ),
),
)
.child(
@@ -2298,7 +2430,11 @@ impl Workbench {
"fav",
RowLead::Icon(icon("icons/star.svg")),
"Starred",
- if self.starred_count > 0 { Some(self.starred_count) } else { None },
+ if self.starred_count > 0 {
+ Some(self.starred_count)
+ } else {
+ None
+ },
self.favorite_only,
RowLevel::Primary,
cx.listener(|this, _, window, cx| {
@@ -2403,7 +2539,11 @@ impl Workbench {
.border_color(theme.sidebar_border)
.when_some(status, |this, status| {
this.child(
- h_flex().px(SPACE_XL).pt(SPACE_MD).text_size(FONT_LABEL).child(status),
+ h_flex()
+ .px(SPACE_XL)
+ .pt(SPACE_MD)
+ .text_size(FONT_LABEL)
+ .child(status),
)
})
.child(
@@ -2420,7 +2560,9 @@ impl Workbench {
// 之后不再跟进(dialog builder 里是静态 rows),
// 首扫途中开出来会是 0 或半截数字且一直不更新
!self.scan.scanning,
- icon("icons/hard-drive.svg").with_size(px(14.)).into_any_element(),
+ icon("icons/hard-drive.svg")
+ .with_size(px(14.))
+ .into_any_element(),
cx.listener(|this, _, window, cx| {
this.show_data_sources(window, cx)
}),
@@ -2468,14 +2610,14 @@ impl Workbench {
.dropdown_menu(move |menu, _, _| {
let mk_key = |label: &'static str, key: SortKey| {
let entity = sort_entity.clone();
- PopupMenuItem::new(label)
- .checked(sort_key == key)
- .on_click(move |_, window, cx| {
+ PopupMenuItem::new(label).checked(sort_key == key).on_click(
+ move |_, window, cx| {
entity.update(cx, |this, cx| {
this.sort_key = key;
this.refresh(window, cx);
});
- })
+ },
+ )
};
let mk_dir = |label: &'static str, ascending: bool| {
let entity = sort_entity.clone();
@@ -2537,7 +2679,10 @@ impl Workbench {
))
.into_any_element()
} else {
- List::new(&self.list_state).flex_1().min_h_0().into_any_element()
+ List::new(&self.list_state)
+ .flex_1()
+ .min_h_0()
+ .into_any_element()
})
}
@@ -2545,7 +2690,12 @@ impl Workbench {
/// gpui::list 的行渲染。在布局阶段经 entity.update 调用(render 已返回,
/// lease 已释放,无 double-lease 风险——与 dialog builder 的时机不同)。
- fn render_msg_row(&mut self, ix: usize, window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
+ fn render_msg_row(
+ &mut self,
+ ix: usize,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) -> AnyElement {
let theme = cx.theme();
let dark = theme.mode.is_dark();
let muted_fg = theme.muted_foreground;
@@ -2705,7 +2855,10 @@ impl Workbench {
px(58.),
px(26.),
"No session selected",
- format!("Pick one from the list, or press {} to search.", search_key_hint()),
+ format!(
+ "Pick one from the list, or press {} to search.",
+ search_key_hint()
+ ),
cx,
)),
)
@@ -3432,7 +3585,11 @@ fn sidebar_row(
.flex_shrink_0()
// 分组项整行右移一档表达从属:行首因此落在轴右侧 SUB_INDENT 处,
// 压轴的是主导航与组头,不是这里
- .pl(if sub { LEAD_INSET + SUB_INDENT } else { LEAD_INSET })
+ .pl(if sub {
+ LEAD_INSET + SUB_INDENT
+ } else {
+ LEAD_INSET
+ })
.pr(SIDEBAR_EDGE)
.rounded(theme.radius)
.cursor_pointer()
@@ -3473,9 +3630,7 @@ fn sidebar_row(
.into_any_element(),
// 品牌图不着色:img 走 AssetSource 取内嵌 PNG,原色渲染
// (侧栏单色化试过,用户否决——保持彩色)
- RowLead::Brand(path) => {
- img(path).size(LEAD_BOX).into_any_element()
- }
+ RowLead::Brand(path) => img(path).size(LEAD_BOX).into_any_element(),
}),
)
.child(
@@ -3492,13 +3647,16 @@ fn sidebar_row(
// 就是 accent,退回 sidebar 材质反衬。固定 muted 会在浅色
// 常态(#E8E8E5 vs #EDEDEA)和深色选中(#323230 vs #343432)
// 两处糊进背景里
- let bg = if active { theme.sidebar } else { theme.sidebar_accent };
- this.child(
- div()
- .flex_shrink_0()
- .text_size(FONT_LABEL)
- .child(badge(n.to_string(), bg, theme.muted_foreground)),
- )
+ let bg = if active {
+ theme.sidebar
+ } else {
+ theme.sidebar_accent
+ };
+ this.child(div().flex_shrink_0().text_size(FONT_LABEL).child(badge(
+ n.to_string(),
+ bg,
+ theme.muted_foreground,
+ )))
}),
)
}
@@ -3515,7 +3673,9 @@ fn tool_btn(
on_click: impl Fn(&ClickEvent, &mut Window, &mut App) + 'static,
) -> Button {
let ic = if highlighted {
- icon(filled_icon_path).with_size(px(16.)).text_color(active_color)
+ icon(filled_icon_path)
+ .with_size(px(16.))
+ .text_color(active_color)
} else {
icon(icon_path).with_size(px(16.))
};