Skip to content

armgit / Wake

Public Imported from GitHub
0

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

Rust

feat(cursor): index IDE Chat/Composer sessions from state.vscdb

珺清458a867c3c73
diff --git a/crates/wake-core/src/adapters/cursor.rs b/crates/wake-core/src/adapters/cursor.rs
index 718d33d..f49d611 100644
--- a/crates/wake-core/src/adapters/cursor.rs
+++ b/crates/wake-core/src/adapters/cursor.rs
@@ -10,7 +10,11 @@ use std::path::{Path, PathBuf};
/// Cursor CLI:`~/.cursor/projects/<slug>/agent-transcripts/<uuid>/<uuid>.jsonl` 明文。
/// 行结构 {role, message:{content:[{type:text|tool_use}]}} + {type:"turn_ended"}。
/// user 正文包在 <timestamp>/<user_query> 壳里;transcript 不含 cwd,
-/// 从有损 slug 目录名 DFS 反推真实路径。IDE chats(store.db 加密)不做。
+/// 从有损 slug 目录名 DFS 反推真实路径。
+///
+/// **同一家的另一个源**:IDE 面板(Chat/Composer)的会话正文在
+/// `globalStorage/state.vscdb`,由 cursor_ide.rs 读;它在本源只留
+/// `{"type":"turn_ended"}` 空壳,枚举时按 `is_turn_marker_only` 跳过。
pub struct CursorAdapter {
root: PathBuf,
}
@@ -300,6 +304,54 @@ fn build_meta(r: &SessionFileRef, p: &CursorParse) -> SessionMeta {
}
}
+/// 这个 transcript 只有回合标记、没有任何对话行吗?
+///
+/// IDE 面板里跑的会话在这里只留 `{"type":"turn_ended"}`,正文全在
+/// `state.vscdb`(cursor_ide.rs 读)。两源同 native_id,而 Cursor 是**回合结束
+/// 之后**才写 turn_ended——空壳的 mtime 必然晚于库里的 lastUpdatedAt,scanner
+/// 的 mtime 裁决会让空壳稳赢,于是 IDE 会话在列表里显示成 0 条消息。空壳压根
+/// 不是一个会话,枚举阶段就不该让它参与竞争。
+///
+/// 判据是"有没有 `"role"` 字段":CLI 会话每一行都是 `{"role":…}`,IDE 空壳
+/// 只有 turn_ended。
+///
+/// **不设文件大小上限**:空壳按每回合一行(约 40 字节)增长,长会话的空壳
+/// 可以很大——"大文件必有正文"是经验观测、不是结构保证,拿它当早退条件会让
+/// 恰好最长最活跃的那些 IDE 会话重新落回 0 消息(2026-09-14 review)。改为
+/// 流式扫描、命中即停:带正文的文件首行就命中(代价与读定长前缀相同),
+/// 只有纯空壳才会读到尾,而它每行都是同一个短标记、总量本就小。
+fn is_turn_marker_only(path: &Path) -> bool {
+ /// 一次读一块,跨块边界靠保留尾巴(见下)
+ const CHUNK: usize = 16 * 1024;
+ /// 跨块保留的字节数:必须 ≥ needle 长度 - 1,否则骑在块边界上的
+ /// `"role"` 会被劈成两半、两块都不命中
+ const NEEDLE: &[u8] = b"\"role\"";
+
+ let Ok(file) = fs::File::open(path) else {
+ // 读不到就别替它下结论,交给解析阶段
+ return false;
+ };
+ let mut reader = std::io::BufReader::with_capacity(CHUNK, file);
+ let mut window: Vec<u8> = Vec::with_capacity(CHUNK + NEEDLE.len());
+ loop {
+ let start = window.len();
+ window.resize(start + CHUNK, 0);
+ let read = match std::io::Read::read(&mut reader, &mut window[start..]) {
+ Ok(0) => break,
+ Ok(n) => n,
+ Err(_) => return false,
+ };
+ window.truncate(start + read);
+ if window.windows(NEEDLE.len()).any(|w| w == NEEDLE) {
+ return false;
+ }
+ // 只留够拼出跨界 needle 的尾巴,其余丢弃——整文件不进内存
+ let keep = window.len().saturating_sub(NEEDLE.len() - 1);
+ window.drain(..keep);
+ }
+ true
+}
+
impl AgentAdapter for CursorAdapter {
fn agent(&self) -> AgentId {
AgentId::Cursor
@@ -328,12 +380,17 @@ impl AgentAdapter for CursorAdapter {
if !meta.is_file() || meta.len() == 0 {
continue;
}
+ let size = meta.len() as i64;
+ // 只有回合标记 = IDE 会话在本源的空壳,正文归 cursor_ide
+ if is_turn_marker_only(&entry.path()) {
+ continue;
+ }
refs.push(SessionFileRef {
agent: AgentId::Cursor,
native_id: name.trim_end_matches(".jsonl").to_string(),
file_path: entry.path().to_string_lossy().to_string(),
mtime_ms: mtime_ms(&meta),
- size: meta.len() as i64,
+ size,
});
}
}
@@ -347,7 +404,13 @@ impl AgentAdapter for CursorAdapter {
if !p.contains("/agent-transcripts/") || p.contains("/subagents/") {
return None;
}
- default_file_ref(self.agent(), path)
+ let r = default_file_ref(self.agent(), path)?;
+ // 与枚举同一判据:IDE 会话每个回合都会 append 一行 turn_ended,
+ // 这里不挡的话 watcher 会把空壳一次次写回,压掉 cursor_ide 的正文
+ if is_turn_marker_only(path) {
+ return None;
+ }
+ Some(r)
}
fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {
@@ -419,6 +482,106 @@ impl AgentAdapter for CursorAdapter {
}
fn data_roots(&self) -> Vec<PathBuf> {
- vec![self.root.clone()]
+ // 空根 = 本条 location 已被用户移除(见 excluding_data_roots)
+ if self.root.as_os_str().is_empty() {
+ Vec::new()
+ } else {
+ vec![self.root.clone()]
+ }
+ }
+
+ /// Cursor 一家两源(本实例的 agent-transcripts 与 cursor_ide 的 state.vscdb),
+ /// 彼此独立:移除其一不该连带关掉另一个。与 cursor_ide 成对,两边必须同时
+ /// 开启——只开一边的话,面板对另一边的 Remove 仍会按 agent 整家压制
+ fn supports_individual_root_removal(&self) -> bool {
+ true
+ }
+
+ /// 单根实例:被排除的是自己的根就交出空根实例(roster 丢弃它);
+ /// 排除列表里是另一个源的根时返回 None(与我无关,原样保留)
+ fn excluding_data_roots(&self, roots: &[PathBuf]) -> Option<Box<dyn AgentAdapter>> {
+ if roots.contains(&self.root) {
+ Some(Box::new(Self {
+ root: PathBuf::new(),
+ }))
+ } else {
+ None
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::io::Write;
+
+ fn write(dir: &std::path::Path, name: &str, body: &str) -> PathBuf {
+ let p = dir.join(name);
+ let mut f = fs::File::create(&p).expect("write fixture");
+ f.write_all(body.as_bytes()).expect("write body");
+ p
+ }
+
+ /// 判据必须与文件大小无关。曾经的实现对 >64KB 的文件直接判"有正文"
+ /// 早退——空壳按每回合一行增长,约 1600 轮后就会越过这条线,于是
+ /// **恰好最长最活跃**的那些 IDE 会话重新落回 0 消息(2026-09-14 review)
+ #[test]
+ fn oversized_stub_is_still_a_stub() {
+ let dir = tempfile::tempdir().expect("tempdir");
+ let line = "{\"type\":\"turn_ended\",\"status\":\"success\"}\n";
+ let huge: String = line.repeat(3000); // ~120KB,远超任何定长探测窗口
+ assert!(huge.len() > 100 * 1024, "这个用例要的就是超大空壳");
+ let p = write(dir.path(), "huge-stub.jsonl", &huge);
+ assert!(
+ is_turn_marker_only(&p),
+ "空壳不因体积变大就变成会话——这正是回归点"
+ );
+ }
+
+ /// 正文判定要命中就停:首行即 role 的常规会话、以及正文远在文件深处
+ /// (前面堆了大量回合标记)的会话,都必须被认成真会话
+ #[test]
+ fn any_role_line_means_real_session() {
+ let dir = tempfile::tempdir().expect("tempdir");
+ let role = "{\"role\":\"user\",\"message\":{\"content\":[]}}\n";
+ let marker = "{\"type\":\"turn_ended\",\"status\":\"success\"}\n";
+
+ let head = write(dir.path(), "head.jsonl", &format!("{role}{marker}"));
+ assert!(!is_turn_marker_only(&head), "首行即 role");
+
+ // role 藏在 100KB 标记之后:定长窗口的实现会漏判,流式扫描不会
+ let deep = write(
+ dir.path(),
+ "deep.jsonl",
+ &format!("{}{role}", marker.repeat(2600)),
+ );
+ assert!(!is_turn_marker_only(&deep), "正文在深处也算真会话");
+ }
+
+ /// `"role"` 骑在读块边界上时不能被劈成两半漏掉。构造:让 needle 的
+ /// 起点正好落在 CHUNK 前一字节处
+ #[test]
+ fn needle_across_chunk_boundary_is_found() {
+ let dir = tempfile::tempdir().expect("tempdir");
+ let chunk = 16 * 1024;
+ for offset in [chunk - 3, chunk - 1, chunk, chunk + 1] {
+ let mut body = "x".repeat(offset);
+ body.push_str("{\"role\":\"user\"}");
+ let p = write(dir.path(), &format!("edge-{offset}.jsonl"), &body);
+ assert!(
+ !is_turn_marker_only(&p),
+ "needle 起点在 {offset} 字节处(跨块)也必须命中"
+ );
+ }
+ }
+
+ /// 读不到的文件不下结论:判为"非空壳"交给解析阶段,
+ /// 绝不能因为打不开就把一个真会话从索引里抹掉
+ #[test]
+ fn unreadable_file_is_not_judged_a_stub() {
+ let dir = tempfile::tempdir().expect("tempdir");
+ assert!(!is_turn_marker_only(
+ &dir.path().join("does-not-exist.jsonl")
+ ));
}
}
diff --git a/crates/wake-core/src/adapters/cursor_ide.rs b/crates/wake-core/src/adapters/cursor_ide.rs
new file mode 100644
index 0000000..946fc84
--- /dev/null
+++ b/crates/wake-core/src/adapters/cursor_ide.rs
@@ -0,0 +1,548 @@
+use super::parse_utils::*;
+use super::sqlite_ro::{open_sqlite_ro, virtual_path};
+use super::{units_from_messages, AgentAdapter};
+use crate::models::*;
+use anyhow::{anyhow, Result};
+use serde_json::Value;
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+/// Cursor IDE 内的 Chat/Composer 历史:`~/Library/Application Support/Cursor/
+/// User/globalStorage/state.vscdb`(Linux/Windows 换用户数据根,见 storage_dir)。
+/// **与 cursor.rs 是同一家的两个数据源**:CLI(`cursor-agent`)把完整对话写
+/// `~/.cursor/.../agent-transcripts/*.jsonl`,IDE 面板只把回合标记
+/// (`{"type":"turn_ended"}`)写进那里、正文全留在本库——所以 IDE 会话在只读
+/// JSONL 的旧实现里是空壳。两源同 native_id 的重叠由 scanner 按 mtime/size
+/// 裁决(不变量 8⑦),这里不做二选一。
+///
+/// 库结构(VS Code 的 KV 表):
+/// - `cursorDiskKV`:`composerData:<composerId>` 是会话元数据 + 气泡顺序
+/// (`fullConversationHeadersOnly[]` 的 `{bubbleId,type}`,type 1=user 2=assistant),
+/// `bubbleId:<composerId>:<bubbleId>` 是单条消息正文(`text`/`thinking`/
+/// `toolFormerData`)。正文**不内联**在 composerData 里,必须按气泡逐条取。
+/// - `composerHeaders`:较新版本才有的索引表,只覆盖一部分会话,
+/// `isSubagent`/`subagentInfo.parentComposerId` 给出子代理归属。老会话没有
+/// 这张表的行,所以枚举**以 composerData 为准**、headers 只作父子关系补充。
+///
+/// **两条已知限制**(2026-09-14 review 记录,都不是本文件能单独解决的):
+/// 1. 不进远程同步。`remote::REMOTE_LAYOUTS` 每个 AgentId 一行,而
+/// `adapters::remote::create_remote_adapters` 按 `find(agent == …)` 取模板
+/// ——同 AgentId 的第二个源拿不到自己的行。更硬的一道是
+/// `sync_paths` 的字符集契约(`remote.rs` 的 `sync_paths_are_shell_safe`:
+/// 路径不加引号直接进 `sh -c` 与 rsync 参数),而本库的路径含空格
+/// (`Application Support`)。补齐远程支持要先给同步管线加引用机制,
+/// 属独立改动;在那之前远程主机只同步得到 Cursor 的 CLI 会话。
+/// 2. 不进文件监听。`data_roots` 给的是库文件,默认 `watch_paths` 只留目录
+/// (`adapters/mod.rs`),故 IDE 新会话要等下一轮扫描才出现——
+/// 与 copilot/antigravity/hermes 等 SQLite 型源同一行为。
+pub struct CursorIdeAdapter {
+ db: PathBuf,
+ /// 枚举要对全部 composerData blob 跑 json_extract(2GB 级库约 5s),
+ /// 一轮扫描里 list_session_files 与 quick_meta 各调一次——按库 mtime 缓存
+ rows_cache: MtimeCache<Vec<IdeRow>>,
+ /// 子代理归属快照(composerHeaders 有行的那部分),同样按库 mtime 失效
+ links_cache: MtimeCache<Vec<(String, String)>>,
+}
+
+/// `globalStorage/state.vscdb` 的宿主目录。VS Code 系三平台的用户数据根不同:
+/// macOS 在 `~/Library/Application Support`,Windows 在 `%APPDATA%`,
+/// Linux 在 `$XDG_CONFIG_HOME`(缺省 `~/.config`)。这里只做路径推导、
+/// 不探测存在性——缺根由 list_session_files 降级为空(roster 契约)。
+/// 三平台都从 `home_dir()` 派生而非 `dirs::config_dir()`:后者在 Windows 上
+/// 走 SHGetKnownFolderPath,`WAKE_HOME` 改道对它无效(见 mod.rs 的 home_dir)
+fn storage_dir() -> PathBuf {
+ let home = super::home_dir().unwrap_or_default();
+ let base = if cfg!(target_os = "macos") {
+ home.join("Library").join("Application Support")
+ } else if cfg!(target_os = "windows") {
+ home.join("AppData").join("Roaming")
+ } else {
+ super::env_dir("XDG_CONFIG_HOME").unwrap_or_else(|| home.join(".config"))
+ };
+ base.join("Cursor").join("User").join("globalStorage")
+}
+
+impl CursorIdeAdapter {
+ pub fn new() -> Self {
+ Self::at(storage_dir().join(DB_NAME))
+ }
+
+ fn at(db: PathBuf) -> Self {
+ Self {
+ db,
+ rows_cache: MtimeCache::new(),
+ links_cache: MtimeCache::new(),
+ }
+ }
+
+ /// 全部有正文的会话(`fullConversationHeadersOnly` 非空)。零消息的草稿
+ /// composer 不进列表——与 copilot 的 `turn_count > 0` 同一口径。
+ ///
+ /// 时间戳三段回退:`lastUpdatedAt` 只有较新的记录才写,缺失时取末条气泡的
+ /// ISO `createdAt`,再缺退 `createdAt`(该字段实测全覆盖)。
+ /// 项目路径优先 `workspaceIdentifier.uri.fsPath`,回退首个 git 仓库路径。
+ fn rows(&self) -> Option<Vec<IdeRow>> {
+ let mtime = super::sqlite_ro::db_cache_stamp(&self.db);
+ self.rows_cache.get_or_try_build(mtime, || {
+ let ro = open_sqlite_ro(&self.db, "cursor-ide")?;
+ let mut stmt = ro
+ .conn
+ .prepare(&format!(
+ "SELECT substr(k.key, {cut}),
+ COALESCE(json_extract(CAST(k.value AS TEXT), '$.name'), ''),
+ COALESCE(json_extract(CAST(k.value AS TEXT), '$.createdAt'), 0),
+ COALESCE(json_extract(CAST(k.value AS TEXT), '$.lastUpdatedAt'), 0),
+ COALESCE(json_extract(CAST(k.value AS TEXT), '$.fullConversationHeadersOnly[#-1].createdAt'), ''),
+ json_array_length(CAST(k.value AS TEXT), '$.fullConversationHeadersOnly'),
+ COALESCE(json_extract(CAST(k.value AS TEXT), '$.workspaceIdentifier.uri.fsPath'), ''),
+ COALESCE(json_extract(CAST(k.value AS TEXT), '$.trackedGitRepos[0].repoPath'), '')
+ FROM cursorDiskKV k
+ WHERE k.key LIKE '{COMPOSER_PREFIX}%'
+ AND json_array_length(CAST(k.value AS TEXT), '$.fullConversationHeadersOnly') > 0",
+ // SQLite substr 是 1-indexed:剥掉前缀 = 从其后一位起。
+ // 两处都由常量推导,前缀改了不会留下静默错位的魔数
+ cut = COMPOSER_PREFIX.len() + 1,
+ ))
+ .ok()?;
+ let rows = stmt
+ .query_map([], |r| {
+ let created: i64 = r.get(2)?;
+ let updated: i64 = r.get(3)?;
+ let last_bubble_ms = iso_ms(&r.get::<_, String>(4)?);
+ let fs_path: String = r.get(6)?;
+ let repo_path: String = r.get(7)?;
+ Ok(IdeRow {
+ id: r.get(0)?,
+ name: r.get(1)?,
+ created_ms: created,
+ updated_ms: pick_updated(updated, last_bubble_ms, created),
+ bubble_count: r.get(5)?,
+ cwd: if fs_path.is_empty() { repo_path } else { fs_path },
+ })
+ })
+ .ok()?
+ .collect::<rusqlite::Result<Vec<_>>>()
+ .ok()?;
+ Some(rows)
+ })
+ }
+
+ fn build_meta(&self, r: &SessionFileRef, row: &IdeRow, message_count: i64) -> SessionMeta {
+ let title = clean_title_candidate(&row.name);
+ SessionMeta {
+ key: format!("cursor:{}", row.id),
+ host: String::new(),
+ id: row.id.clone(),
+ agent: AgentId::Cursor,
+ title: if title.is_empty() {
+ UNTITLED.to_string()
+ } else {
+ title
+ },
+ project_path: row.cwd.clone(),
+ project_name: project_name_of(&row.cwd),
+ file_path: r.file_path.clone(),
+ created_at: if row.created_ms > 0 {
+ row.created_ms
+ } else {
+ r.mtime_ms
+ },
+ updated_at: if row.updated_ms > 0 {
+ row.updated_ms
+ } else {
+ r.mtime_ms
+ },
+ message_count,
+ size_bytes: r.size,
+ git_branch: None,
+ model: None,
+ tokens_used: None,
+ archived: false,
+ source: None,
+ favorite: false,
+ pinned: false,
+ }
+ }
+
+ /// 单会话解析:一次连接,先读 composerData 拿气泡顺序,再按
+ /// `bubbleId:<cid>:` 前缀范围扫出正文。**顺序只认
+ /// `fullConversationHeadersOnly`**——KV 表按 key 字典序,而 bubbleId 是
+ /// 随机 UUID,照 key 序读会把对话打乱。
+ fn parse(&self, r: &SessionFileRef) -> Result<(SessionMeta, Vec<TranscriptMessage>)> {
+ let ro = open_sqlite_ro(&self.db, "cursor-ide")
+ .ok_or_else(|| anyhow!("cannot open cursor IDE store"))?;
+ let raw: String = ro
+ .conn
+ .query_row(
+ "SELECT CAST(value AS TEXT) FROM cursorDiskKV WHERE key = ?1",
+ [format!("{COMPOSER_PREFIX}{}", r.native_id)],
+ |x| x.get(0),
+ )
+ .map_err(|_| anyhow!("cursor composer {} not in store", r.native_id))?;
+ let data: Value = serde_json::from_str(&raw)?;
+
+ // 气泡正文单独存 KV,一次范围扫描全取回来(逐条点查是 N 次往返)。
+ // 上界用同前缀接 U+FFFF:UUID 只含 [0-9a-f-],不会越界到别的会话
+ let prefix = format!("{BUBBLE_PREFIX}{}:", r.native_id);
+ let mut bubbles: HashMap<String, Value> = HashMap::new();
+ {
+ let mut stmt = ro.conn.prepare(
+ "SELECT substr(key, ?2), CAST(value AS TEXT) FROM cursorDiskKV
+ WHERE key >= ?1 AND key < ?3",
+ )?;
+ let upper = format!("{prefix}\u{FFFF}");
+ let cut = prefix.len() as i64 + 1;
+ let mut found = stmt.query(rusqlite::params![&prefix, cut, &upper])?;
+ while let Some(row) = found.next()? {
+ let id: String = row.get(0)?;
+ let body: String = row.get(1)?;
+ if let Ok(v) = serde_json::from_str::<Value>(&body) {
+ bubbles.insert(id, v);
+ }
+ }
+ }
+
+ let order = data
+ .get("fullConversationHeadersOnly")
+ .and_then(|v| v.as_array())
+ .cloned()
+ .unwrap_or_default();
+ let mut messages: Vec<TranscriptMessage> = Vec::new();
+ for head in &order {
+ let Some(bid) = head.get("bubbleId").and_then(|v| v.as_str()) else {
+ continue;
+ };
+ // 顺序表里有、KV 里没有:气泡行已被 Cursor 清理(老会话常见)
+ let Some(bubble) = bubbles.get(bid) else {
+ continue;
+ };
+ // 角色以顺序表为准、气泡自带的 type 兜底(两处写同一枚举)
+ let kind = head
+ .get("type")
+ .and_then(|v| v.as_i64())
+ .or_else(|| bubble.get("type").and_then(|v| v.as_i64()))
+ .unwrap_or(BUBBLE_ASSISTANT);
+ if let Some(msg) = bubble_message(bubble, kind) {
+ messages.push(msg);
+ }
+ }
+ assign_seq(&mut messages);
+
+ let count = messages
+ .iter()
+ .filter(|m| m.kind == MessageKind::Text)
+ .count() as i64;
+ // 枚举快照优先(与列表页同源);库在扫描与打开详情之间变过时就地重建
+ let row = self
+ .rows()
+ .and_then(|rows| rows.into_iter().find(|x| x.id == r.native_id))
+ .unwrap_or_else(|| IdeRow::from_data(&r.native_id, &data, order.len() as i64));
+ let mut meta = self.build_meta(r, &row, count);
+ // composer 没起名时(新建会话、或 Cursor 还没生成摘要)回退首条用户消息
+ if meta.title == UNTITLED {
+ if let Some(t) = title_from_messages(&messages) {
+ meta.title = t;
+ }
+ }
+ Ok((meta, messages))
+ }
+}
+
+const DB_NAME: &str = "state.vscdb";
+/// `cursorDiskKV` 里会话元数据行的 key 前缀。**长度参与 SQL 的 substr 偏移**
+/// (见 `rows`),所以只能有这一处字面量——写死的偏移量与前缀改动脱节时,
+/// 剥出来的 id 会静默少几个字符
+const COMPOSER_PREFIX: &str = "composerData:";
+/// 单条消息正文行的 key 前缀,完整形态 `bubbleId:<composerId>:<bubbleId>`
+const BUBBLE_PREFIX: &str = "bubbleId:";
+/// `fullConversationHeadersOnly[].type` 与气泡自带 `type` 的取值
+const BUBBLE_USER: i64 = 1;
+const BUBBLE_ASSISTANT: i64 = 2;
+
+/// `composerHeaders.isSubagent=1` 的行带 `subagentInfo.parentComposerId`。
+/// 这张表只覆盖较新的会话,老会话查不到父子关系——不是错误,照常列为顶层。
+fn parent_links_from(db: &std::path::Path) -> Option<Vec<(String, String)>> {
+ let ro = open_sqlite_ro(db, "cursor-ide")?;
+ let mut stmt = ro
+ .conn
+ .prepare(
+ "SELECT composerId, json_extract(value, '$.subagentInfo.parentComposerId')
+ FROM composerHeaders WHERE isSubagent = 1",
+ )
+ .ok()?;
+ let rows = stmt
+ .query_map([], |r| {
+ Ok((r.get::<_, String>(0)?, r.get::<_, Option<String>>(1)?))
+ })
+ .ok()?
+ .collect::<rusqlite::Result<Vec<_>>>()
+ .ok()?;
+ Some(
+ rows.into_iter()
+ .filter_map(|(child, parent)| {
+ let parent = parent?;
+ // 自指会在关系图里成环,空父等于没有关系
+ if parent.is_empty() || parent == child {
+ return None;
+ }
+ Some((format!("cursor:{child}"), format!("cursor:{parent}")))
+ })
+ .collect(),
+ )
+}
+
+/// updated_at 的三段回退,见 `rows` 的说明
+fn pick_updated(last_updated: i64, last_bubble: i64, created: i64) -> i64 {
+ if last_updated > 0 {
+ last_updated
+ } else if last_bubble > 0 {
+ last_bubble
+ } else {
+ created
+ }
+}
+
+/// 一条气泡 → 一条消息。空壳气泡(无正文、无思考、无工具)返回 None:
+/// Cursor 每个流式分片都落一条气泡,绝大多数是没有 text 的中间态。
+fn bubble_message(bubble: &Value, kind: i64) -> Option<TranscriptMessage> {
+ let role = if kind == BUBBLE_USER {
+ Role::User
+ } else {
+ Role::Assistant
+ };
+ let ts = bubble
+ .get("createdAt")
+ .and_then(|v| v.as_str())
+ .map(iso_ms)
+ .unwrap_or(0);
+ let text = bubble
+ .get("text")
+ .and_then(|v| v.as_str())
+ .unwrap_or_default();
+ let thinking = bubble
+ .get("thinking")
+ .and_then(|t| t.get("text"))
+ .and_then(|v| v.as_str())
+ .filter(|s| !s.trim().is_empty())
+ .map(|s| clip(s, MAX_MSG_TEXT).0);
+ let tool = bubble.get("toolFormerData").and_then(tool_from);
+
+ if text.trim().is_empty() && thinking.is_none() && tool.is_none() {
+ return None;
+ }
+ let mut msg = text_msg(role, text, ts);
+ msg.thinking = thinking;
+ msg.tool_calls = tool.into_iter().collect();
+ Some(msg)
+}
+
+/// 取一个"可能被双重编码"的字段:Cursor 对同一字段有时写 JSON 字符串
+///(`"{\"path\":…}"`)、有时直接写对象。字符串能再解析就解析,解析不动
+/// 就当纯文本保留(命令行、自由文本参数都是这一类)。空值一律 None。
+fn json_field(data: &Value, key: &str) -> Option<Value> {
+ match data.get(key)? {
+ Value::String(s) if s.trim().is_empty() => None,
+ Value::String(s) => {
+ Some(serde_json::from_str(s).unwrap_or_else(|_| Value::String(s.clone())))
+ }
+ Value::Null => None,
+ other => Some(other.clone()),
+ }
+}
+
+/// `toolFormerData` → ToolCallView。
+///
+/// 参数有两个来源,**必须都读**:`rawArgs` 是模型原样吐出的 JSON 串,
+/// `params` 是 Cursor 归一化后的形态。实测约 11% 的调用只有后者——
+/// 且恰好是最该被搜到的那些(run_terminal_command_v2 的命令行、
+/// edit_file_v2 的目标文件、task_v2 的子任务描述),只读 rawArgs 会让
+/// 这些工具在索引里变成没有输入的空调用。
+/// `result` 同理:多数工具写 JSON 串,终端类写 `{"output":…}` 对象。
+fn tool_from(data: &Value) -> Option<ToolCallView> {
+ let name = data.get("name").and_then(|v| v.as_str()).unwrap_or("tool");
+ let id = data
+ .get("toolCallId")
+ .and_then(|v| v.as_str())
+ .unwrap_or_default();
+ let input = json_field(data, "rawArgs")
+ .or_else(|| json_field(data, "params"))
+ .unwrap_or(Value::Null);
+ let output = json_field(data, "result").map(|v| match v {
+ // 终端类工具把正文包在 output 里,直接展平成人读的文本;
+ // 其余形态保持 JSON(工具结果的结构本身就是信息)
+ Value::Object(ref o) => o
+ .get("output")
+ .and_then(|x| x.as_str())
+ .map(str::to_string)
+ .unwrap_or_else(|| v.to_string()),
+ Value::String(s) => s,
+ other => other.to_string(),
+ });
+ let is_error = data
+ .get("status")
+ .and_then(|v| v.as_str())
+ .is_some_and(|s| s == "error");
+ Some(tool_call_view(
+ id.to_string(),
+ name,
+ &input,
+ output,
+ is_error,
+ ))
+}
+
+#[derive(Clone)]
+struct IdeRow {
+ id: String,
+ name: String,
+ created_ms: i64,
+ updated_ms: i64,
+ bubble_count: i64,
+ cwd: String,
+}
+
+impl IdeRow {
+ /// 枚举快照里没有这条时的兜底(库在扫描与打开详情之间变过)
+ fn from_data(id: &str, data: &Value, bubble_count: i64) -> Self {
+ let created = data.get("createdAt").and_then(|v| v.as_i64()).unwrap_or(0);
+ let updated = data
+ .get("lastUpdatedAt")
+ .and_then(|v| v.as_i64())
+ .unwrap_or(0);
+ let cwd = data
+ .pointer("/workspaceIdentifier/uri/fsPath")
+ .and_then(|v| v.as_str())
+ .or_else(|| {
+ data.pointer("/trackedGitRepos/0/repoPath")
+ .and_then(|v| v.as_str())
+ })
+ .unwrap_or_default();
+ Self {
+ id: id.to_string(),
+ name: data
+ .get("name")
+ .and_then(|v| v.as_str())
+ .unwrap_or_default()
+ .to_string(),
+ created_ms: created,
+ updated_ms: pick_updated(updated, 0, created),
+ bubble_count,
+ cwd: cwd.to_string(),
+ }
+ }
+}
+
+impl AgentAdapter for CursorIdeAdapter {
+ fn agent(&self) -> AgentId {
+ AgentId::Cursor
+ }
+
+ fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
+ let Some(rows) = self.rows() else {
+ return Ok(Vec::new());
+ };
+ Ok(rows
+ .into_iter()
+ .map(|row| SessionFileRef {
+ agent: AgentId::Cursor,
+ native_id: row.id.clone(),
+ file_path: virtual_path(&self.db, &row.id),
+ mtime_ms: row.updated_ms,
+ // 正文在别的 KV 行里,枚举时不展开;气泡条数即内容指纹
+ //(会话续跑必然追加气泡),与 mtime 共同构成 dirty 判断
+ size: row.bubble_count,
+ })
+ .collect())
+ }
+
+ fn quick_meta(&self, refs: &[SessionFileRef]) -> Option<HashMap<String, SessionMeta>> {
+ let rows = self.rows()?;
+ let by_id: HashMap<&str, &IdeRow> = rows.iter().map(|r| (r.id.as_str(), r)).collect();
+ let mut out = HashMap::new();
+ for r in refs {
+ if let Some(row) = by_id.get(r.native_id.as_str()) {
+ out.insert(
+ r.file_path.clone(),
+ self.build_meta(r, row, row.bubble_count),
+ );
+ }
+ }
+ Some(out)
+ }
+
+ fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
+ let (meta, messages) = self.parse(r)?;
+ let units = units_from_messages(&messages);
+ Ok(ParsedSession {
+ meta,
+ units,
+ unknown_line_count: 0,
+ })
+ }
+
+ fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
+ let (meta, messages) = self.parse(r)?;
+ Ok(ParsedTranscript {
+ meta,
+ mainline: messages,
+ sidechains: Vec::new(),
+ unknown_line_count: 0,
+ })
+ }
+
+ fn manages_parent_links(&self) -> bool {
+ true
+ }
+
+ fn parent_links(&self) -> Vec<(String, String)> {
+ let mtime = super::sqlite_ro::db_cache_stamp(&self.db);
+ self.links_cache
+ .get_or_try_build(mtime, || parent_links_from(&self.db))
+ .unwrap_or_default()
+ }
+
+ fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
+ // 直接给到库文件、给 globalStorage 目录、或给 Cursor 用户数据根
+ //(含 User/globalStorage/)都认——与 copilot/antigravity 同一判序
+ let db = if dir.is_file() {
+ dir
+ } else {
+ let nested = dir.join("User").join("globalStorage").join(DB_NAME);
+ if nested.is_file() {
+ nested
+ } else {
+ dir.join(DB_NAME)
+ }
+ };
+ Box::new(Self::at(db))
+ }
+
+ fn data_roots(&self) -> Vec<PathBuf> {
+ // 空 db 路径 = 本条 location 已被用户移除(见 excluding_data_roots),
+ // 此时如实报告"没有数据根",roster 组装处据此整体丢弃本实例
+ if self.db.as_os_str().is_empty() {
+ Vec::new()
+ } else {
+ vec![self.db.clone()]
+ }
+ }
+
+ /// Cursor 一家两源(本实例的 state.vscdb 与 cursor.rs 的 agent-transcripts),
+ /// 彼此独立。不开这个能力位的话,面板上的 Remove 会走 `removed_defaults`
+ /// 按 agent 整家压制——移除其中一条 location,另一条跟着消失
+ ///(同 OpenCode 的 stable/next 两库)
+ fn supports_individual_root_removal(&self) -> bool {
+ true
+ }
+
+ /// 单根实例:被排除的是自己的根就交出空根实例(roster 丢弃它);
+ /// 排除列表按 agent 收集,里面可能是**另一个源**的根,那种情况返回
+ /// None 表示"与我无关,原样保留"
+ fn excluding_data_roots(&self, roots: &[PathBuf]) -> Option<Box<dyn AgentAdapter>> {
+ if roots.contains(&self.db) {
+ Some(Box::new(Self::at(PathBuf::new())))
+ } else {
+ None
+ }
+ }
+}
diff --git a/crates/wake-core/src/adapters/mod.rs b/crates/wake-core/src/adapters/mod.rs
index c821241..dfa2c41 100644
--- a/crates/wake-core/src/adapters/mod.rs
+++ b/crates/wake-core/src/adapters/mod.rs
@@ -4,6 +4,7 @@ pub mod codebuddy;
pub mod codex;
pub mod copilot;
pub mod cursor;
+pub mod cursor_ide;
pub mod dsh;
pub mod gemini;
pub mod grok;
@@ -186,7 +187,12 @@ pub(crate) fn home_dir() -> Option<std::path::PathBuf> {
/// 对 Err 会 `?` 截断整轮,新 adapter 必须维持这条降级约定,contract 测试
/// 有卡)。**不要为任何用途二次构造 roster**:根路径是构造时刻对 env
/// (CODEX_HOME/XDG_DATA_HOME)与文件系统的快照,两份实例可能解析出不同的
-/// 根,UI 就会展示一个扫描器并不在读的路径
+/// 根,UI 就会展示一个扫描器并不在读的路径。
+///
+/// **家数 ≠ 实例数**:Cursor 一家有两个数据源(CLI 的 agent-transcripts
+/// 与 IDE 的 state.vscdb),各占一个实例、共用 `AgentId::Cursor`。两源对
+/// 同一 composer 都有记录时(IDE 会话在 JSONL 侧是只含 turn_ended 的空壳),
+/// 由 scanner 的同家同 ID 去重按 mtime/size 裁决
pub fn create_adapters() -> Vec<Box<dyn AgentAdapter>> {
vec![
Box::new(claude::ClaudeAdapter::new()),
@@ -194,6 +200,7 @@ pub fn create_adapters() -> Vec<Box<dyn AgentAdapter>> {
Box::new(qoder::QoderAdapter::new()),
Box::new(copilot::CopilotAdapter::new()),
Box::new(cursor::CursorAdapter::new()),
+ Box::new(cursor_ide::CursorIdeAdapter::new()),
Box::new(opencode::OpencodeAdapter::new()),
Box::new(kiro::KiroAdapter::new()),
Box::new(gemini::GeminiAdapter::new()),
diff --git a/crates/wake-core/src/remote.rs b/crates/wake-core/src/remote.rs
index 54815c7..2fedcd4 100644
--- a/crates/wake-core/src/remote.rs
+++ b/crates/wake-core/src/remote.rs
@@ -86,6 +86,12 @@ pub const REMOTE_LAYOUTS: &[RemoteAgentLayout] = &[
},
RemoteAgentLayout {
agent: AgentId::Cursor,
+ // 只覆盖 CLI 源。Cursor 还有一个 IDE 源(adapters/cursor_ide.rs,
+ // `globalStorage/state.vscdb`),**不在远程同步范围内**:本表每个
+ // AgentId 一行、create_remote_adapters 按 agent 取首个模板,同家第二
+ // 个源拿不到自己的行;且该库路径含空格,过不了下方
+ // `sync_paths_are_shell_safe`(路径不加引号直接进 sh -c 与 rsync)。
+ // 要补齐得先给同步管线加引用机制,是独立改动(2026-09-14 review)
mount: ".cursor/projects",
sync_paths: &[".cursor/projects"],
exclude: &[],
diff --git a/crates/wake-core/tests/adapter_contracts.rs b/crates/wake-core/tests/adapter_contracts.rs
index 735b6ef..a9cce78 100644
--- a/crates/wake-core/tests/adapter_contracts.rs
+++ b/crates/wake-core/tests/adapter_contracts.rs
@@ -19,6 +19,7 @@ use wake_core::adapters::codebuddy::CodebuddyAdapter;
use wake_core::adapters::codex::CodexAdapter;
use wake_core::adapters::copilot::CopilotAdapter;
use wake_core::adapters::cursor::CursorAdapter;
+use wake_core::adapters::cursor_ide::CursorIdeAdapter;
use wake_core::adapters::dsh::DshAdapter;
use wake_core::adapters::gemini::GeminiAdapter;
use wake_core::adapters::grok::GrokAdapter;
@@ -45,6 +46,7 @@ struct TestEnv {
dsh_log: PathBuf,
hermes_db: PathBuf,
openclaw_db: PathBuf,
+ cursor_ide_db: PathBuf,
/// 假 HOME 目录本体,持有 TempDir 保证整个测试进程期间不被清理
_home: tempfile::TempDir,
}
@@ -73,6 +75,7 @@ fn setup() -> &'static TestEnv {
dsh_log: sc.dsh_log,
hermes_db: sc.hermes_db,
openclaw_db: sc.openclaw_db,
+ cursor_ide_db: sc.cursor_ide_db,
_home: home,
}
})
@@ -98,6 +101,12 @@ fn fs_ref(agent: AgentId, path: &Path, native_id: &str) -> SessionFileRef {
}
}
+/// 默认 roster 的实例数。**不等于 `AgentId::ALL.len()`**:Cursor 一家有两个
+/// 数据源(CLI 的 agent-transcripts 与 IDE 的 state.vscdb),各占一个实例。
+/// 新增 agent 或给某家再加数据源时,这个数跟着加一——契约要卡的是"漏了实例
+/// 就爆",而不是"每家恰好一个"
+const DEFAULT_INSTANCES: usize = AgentId::ALL.len() + 1;
+
/// SQLite 型 agent 的虚拟路径引用(`<db>#<id>`,与 sqlite_ro::virtual_path 同构)
fn db_ref(agent: AgentId, db: &Path, id: &str) -> SessionFileRef {
SessionFileRef {
@@ -575,6 +584,209 @@ fn qoder_explicit_null_active_leaf_is_empty() {
assert_eq!(s.unknown_line_count, 0);
}
+/// Cursor IDE(state.vscdb):正文按 `fullConversationHeadersOnly` 的气泡顺序
+/// 组装。fixture 里 KV 的 key 字典序(aa/bb/cc/kk/mm/zz)与对话顺序
+/// (zz→aa→mm→bb→cc→kk)**故意相反**——照 key 序读就会把对话打乱,这是
+/// 本测试要防的主要回归。
+/// Cursor 一家两源:移除其中一条 location 不得连带关掉另一条。
+/// 两个实例都必须开 `supports_individual_root_removal`——否则面板的 Remove
+/// 会退回 `removed_defaults` 的按 agent 整家压制,用户移除 CLI 转录目录时
+/// IDE 会话会一起消失(反之亦然)。
+#[test]
+fn cursor_two_sources_remove_independently() {
+ let _env = setup();
+ let roster = wake_core::adapters::create_adapters();
+ let cursors: Vec<&Box<dyn wake_core::adapters::AgentAdapter>> = roster
+ .iter()
+ .filter(|a| a.agent() == AgentId::Cursor)
+ .collect();
+ assert_eq!(cursors.len(), 2, "Cursor 应有 CLI 与 IDE 两个数据源");
+ for a in &cursors {
+ assert!(
+ a.supports_individual_root_removal(),
+ "两源都要能单独移除,只开一边等于没开"
+ );
+ }
+
+ // 排除 A 的根:A 交出空根实例(roster 组装处据此丢弃),B 原样保留
+ let (a, b) = (cursors[0], cursors[1]);
+ let a_root = a.data_roots();
+ assert_eq!(a_root.len(), 1, "两源各自单根");
+ let trimmed = a
+ .excluding_data_roots(&a_root)
+ .expect("移除自己的根应给出替代实例");
+ assert!(
+ trimmed.data_roots().is_empty(),
+ "自己的根被移除后不应再声明数据根"
+ );
+ assert!(
+ b.excluding_data_roots(&a_root).is_none(),
+ "另一源的根与我无关,应原样保留"
+ );
+}
+
+/// 同 AgentId 两实例下的路由:会话必须落到**拥有其 file_path 的那个源**。
+/// 这条不成立时后果不对称——IDE 会话的虚拟路径 `<db>#<id>` 若被路由到 CLI
+/// 实例,`cursor.rs::session_paths` 会取其父目录(= 整个 globalStorage/)
+/// 交给删除流程,一次删除就会端掉 Cursor 的全部 IDE 数据。
+#[test]
+fn cursor_two_sources_route_by_path() {
+ let env = setup();
+ let roster = wake_core::adapters::create_adapters();
+
+ // IDE 的虚拟路径 → IDE 实例,且它不把库文件的父目录当会话目录
+ let ide_path = format!("{}#cide-0001", env.cursor_ide_db.display());
+ let ide = wake_core::adapters::adapter_for(&roster, AgentId::Cursor, &ide_path)
+ .expect("IDE 虚拟路径必须有实例认领");
+ assert_eq!(ide.data_roots(), vec![env.cursor_ide_db.clone()]);
+ let ide_meta = ide
+ .parse_session(&db_ref(AgentId::Cursor, &env.cursor_ide_db, "cide-0001"))
+ .expect("ide parse")
+ .meta;
+ let targets = ide.session_paths(&ide_meta);
+ assert_eq!(
+ targets,
+ vec![ide_path.clone()],
+ "SQLite 型会话的删除目标是虚拟路径本身(磁盘上不存在,trash 会跳过),\
+ 绝不能是库文件所在目录"
+ );
+ assert!(
+ !targets.iter().any(|t| t.ends_with("globalStorage")),
+ "删除目标落到 globalStorage 目录就会端掉整个 Cursor IDE 数据"
+ );
+
+ // CLI 的真实文件路径 → CLI 实例
+ let cli_path = fixture(
+ "cursor/projects/wakefx-cursor-proj/agent-transcripts/33333333-aaaa-bbbb-cccc-000000000003/33333333-aaaa-bbbb-cccc-000000000003.jsonl",
+ );
+ let cli =
+ wake_core::adapters::adapter_for(&roster, AgentId::Cursor, &cli_path.to_string_lossy())
+ .expect("CLI 路径必须有实例认领");
+ assert_ne!(
+ cli.data_roots(),
+ vec![env.cursor_ide_db.clone()],
+ "CLI 转录不该落到 IDE 实例"
+ );
+}
+
+#[test]
+fn cursor_ide_parse_contract() {
+ let env = setup();
+ let adapter = CursorIdeAdapter::new();
+
+ // 枚举:零气泡的草稿不进列表,有正文的三条都在
+ let mut ids: Vec<String> = adapter
+ .list_session_files()
+ .expect("cursor ide list")
+ .into_iter()
+ .map(|r| r.native_id)
+ .collect();
+ ids.sort();
+ assert_eq!(ids, vec!["cide-0001", "cide-0002", "cide-0004"]);
+
+ let r = db_ref(AgentId::Cursor, &env.cursor_ide_db, "cide-0001");
+ let s = adapter.parse_session(&r).expect("cursor ide parse_session");
+ let t = adapter
+ .parse_transcript(&r)
+ .expect("cursor ide parse_transcript");
+
+ // 与 cursor.rs(CLI 源)共用 AgentId 与 key 前缀:同一 composer 在两源
+ // 各有一份时,scanner 才能按同一 key 去重裁决
+ assert_eq!(s.meta.key, "cursor:cide-0001");
+ assert_eq!(s.meta.agent, AgentId::Cursor);
+ assert_eq!(s.meta.title, "Cursor IDE QR fix");
+ assert_eq!(s.meta.project_path, "/Users/tester/Github/wakefx");
+ assert_eq!(s.meta.project_name, "wakefx");
+ assert_eq!(s.meta.created_at, 1786300000000);
+ assert_eq!(s.meta.updated_at, 1786300600000);
+ assert!(s.meta.file_path.ends_with("#cide-0001"));
+ assert_eq!(s.unknown_line_count, 0);
+
+ // 空壳流式气泡(bb)与已被清理的气泡(cc)都不产出消息
+ assert_eq!(
+ roles_kinds(&t.mainline),
+ vec![
+ (Role::User, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ (Role::Assistant, MessageKind::Text),
+ ]
+ );
+ assert!(t.mainline[0].text.contains("二维码扫描为何闪退"));
+ assert_eq!(
+ t.mainline[1].thinking.as_deref(),
+ Some("先查 effect 依赖和清理函数")
+ );
+ assert_eq!(t.mainline[2].tool_calls.len(), 1);
+ assert_eq!(t.mainline[2].tool_calls[0].name, "grep");
+ assert_eq!(t.mainline[2].tool_calls[0].id, "call_ide_1");
+ assert!(t.mainline[2].tool_calls[0]
+ .output
+ .as_deref()
+ .is_some_and(|o| o.contains("QrScanner.tsx")));
+ assert!(!t.mainline[2].tool_calls[0].is_error);
+
+ // rawArgs 为空、参数只在 params 的形态(真实库里占 11%,且全是
+ // 终端命令/文件编辑这类最该被搜到的调用)
+ let term = &t.mainline[3].tool_calls[0];
+ assert_eq!(term.name, "run_terminal_command_v2");
+ assert!(
+ term.input
+ .as_deref()
+ .is_some_and(|i| i.contains("cargo test -p wakefx")),
+ "params 里的命令行必须进 input,否则终端调用在索引里是空的"
+ );
+ assert!(
+ term.input_preview.contains("cargo test"),
+ "FTS 收的是 preview,命令行必须出现在这里"
+ );
+ assert_eq!(
+ term.output.as_deref(),
+ Some("test result: ok. 3 passed"),
+ "终端结果包在 {{\"output\":…}} 对象里,应展平成人读文本"
+ );
+ assert!(t.mainline[4].text.contains("已在清理回调里停止扫描"));
+ assert_eq!(
+ t.mainline[0].timestamp,
+ Some(ms("2026-08-09T10:00:05.000Z"))
+ );
+ assert_eq!(
+ t.mainline[4].timestamp,
+ Some(ms("2026-08-09T10:00:12.000Z"))
+ );
+ // FTS 单元只收 text 与工具名/输入摘要(units_from_messages 的全局口径),
+ // seq 1 是纯 thinking 消息、正文为空,故不进索引——详情页仍然有它
+ assert_eq!(
+ s.units.iter().map(|u| u.seq).collect::<Vec<_>>(),
+ vec![0, 2, 3, 4]
+ );
+ assert!(
+ s.units.iter().any(|u| u.text.contains("cargo test")),
+ "终端命令必须能被搜到"
+ );
+
+ // name 为空 + 无 lastUpdatedAt:标题回退首条用户消息,
+ // updated_at 回退末条气泡的 ISO createdAt
+ let r2 = db_ref(AgentId::Cursor, &env.cursor_ide_db, "cide-0002");
+ let s2 = adapter
+ .parse_session(&r2)
+ .expect("cursor ide fallback parse");
+ assert_eq!(s2.meta.title, "空 name 会话的兜底标题应取这句");
+ assert_eq!(s2.meta.created_at, 1786310000000);
+ assert_eq!(s2.meta.updated_at, ms("2026-08-09T11:00:20.000Z"));
+
+ // 子代理归属来自 composerHeaders.subagentInfo
+ assert!(adapter.manages_parent_links());
+ assert_eq!(
+ adapter.parent_links(),
+ vec![(
+ "cursor:cide-0004".to_string(),
+ "cursor:cide-0001".to_string()
+ )]
+ );
+}
+
#[test]
fn copilot_parse_contract() {
let env = setup();
@@ -1265,16 +1477,16 @@ fn overlapping_watch_roots_dispatch_to_deepest() {
#[test]
fn data_roots_contract() {
- // roster 单实例契约:create_adapters 返回全量各家(不按 detect 过滤,
- // scanner 对缺根家靠各自 list_session_files 降级为空);每家必须给出
+ // roster 覆盖契约:create_adapters 返回全量各家(不按 detect 过滤,
+ // scanner 对缺根家靠各自 list_session_files 降级为空);每个实例必须给出
// 绝对路径的数据根——"Session locations" 面板、watch_paths 派生、按
// (agent, 根) 计数全都建立在它上面
let _env = setup();
let adapters = wake_core::adapters::create_adapters();
assert_eq!(
adapters.len(),
- AgentId::ALL.len(),
- "全量 roster 必须每家一个实例,含本机没装的"
+ DEFAULT_INSTANCES,
+ "全量 roster 必须含每家(本机没装的也在)与每个数据源"
);
for a in &adapters {
let tag = a.agent().as_str();
@@ -1952,6 +2164,9 @@ fn agent_id_all_matches_ord_and_roster() {
.map(|a| a.agent())
.collect();
roster.sort();
+ // 一家可以有多个数据源(Cursor 的 CLI + IDE),集合比较前先去重——
+ // 这里要卡的是"某家整个漏出 roster 或漏出 ALL",不是实例个数
+ roster.dedup();
let mut all = AgentId::ALL.to_vec();
all.sort();
assert_eq!(all, roster, "ALL 与 roster 的 agent 集合不一致");
@@ -1963,7 +2178,7 @@ fn agent_id_all_matches_ord_and_roster() {
fn removed_defaults_suppress_instances() {
setup();
let roster = wake_core::adapters::create_adapters_with(&[], &[AgentId::ClaudeCode]);
- assert_eq!(roster.len(), AgentId::ALL.len() - 1);
+ assert_eq!(roster.len(), DEFAULT_INSTANCES - 1);
assert!(roster.iter().all(|a| a.agent() != AgentId::ClaudeCode));
let dir = tempfile::tempdir().unwrap();
@@ -2261,7 +2476,7 @@ fn adapter_ix_for_routes_to_owning_instance() {
let custom = dir.path().to_path_buf();
let roster =
wake_core::adapters::create_adapters_with(&[(AgentId::ClaudeCode, custom.clone())], &[]);
- let defaults = AgentId::ALL.len();
+ let defaults = DEFAULT_INSTANCES;
assert_eq!(roster.len(), defaults + 1, "全量默认 + 1 自定义");
assert_eq!(roster[defaults].agent(), AgentId::ClaudeCode);
diff --git a/crates/wake-core/tests/common/mod.rs b/crates/wake-core/tests/common/mod.rs
index 11ad540..fd6dc6c 100644
--- a/crates/wake-core/tests/common/mod.rs
+++ b/crates/wake-core/tests/common/mod.rs
@@ -57,6 +57,7 @@ pub struct Sidecars {
pub dsh_log: PathBuf,
pub hermes_db: PathBuf,
pub openclaw_db: PathBuf,
+ pub cursor_ide_db: PathBuf,
}
/// 侧档与 SQLite 型 fixture 库:copilot/opencode(两代)/antigravity 现建库,
@@ -146,6 +147,13 @@ pub fn stage_sidecars(home: &Path) -> Sidecars {
let openclaw_db = claw_dir.join("openclaw-agent.sqlite");
build_openclaw_db(&openclaw_db);
+ // Cursor IDE:VS Code 系的用户数据根三平台不同,与 adapter 的 storage_dir
+ // 同一推导(WAKE_HOME 下派生,不走 dirs::config_dir)
+ let cursor_ide_dir = cursor_ide_storage_dir(home);
+ fs::create_dir_all(&cursor_ide_dir).expect("mkdir cursor globalStorage");
+ let cursor_ide_db = cursor_ide_dir.join("state.vscdb");
+ build_cursor_ide_db(&cursor_ide_db);
+
Sidecars {
copilot_db,
opencode_db,
@@ -154,9 +162,23 @@ pub fn stage_sidecars(home: &Path) -> Sidecars {
dsh_log,
hermes_db,
openclaw_db,
+ cursor_ide_db,
}
}
+/// `<home>/…/Cursor/User/globalStorage`,与 adapters::cursor_ide::storage_dir
+/// 的平台分支逐条对应(改一处必须改另一处,契约测试会因路径不符而空列)
+pub fn cursor_ide_storage_dir(home: &Path) -> PathBuf {
+ let base = if cfg!(target_os = "macos") {
+ home.join("Library").join("Application Support")
+ } else if cfg!(target_os = "windows") {
+ home.join("AppData").join("Roaming")
+ } else {
+ home.join(".config")
+ };
+ base.join("Cursor").join("User").join("globalStorage")
+}
+
/// Hermes `state.db` 最小同构库:sessions + messages(时间戳 unix 秒 REAL)。
/// hs-0001 有用户标题、OpenAI 形状的 tool_calls 与 reasoning;hs-0002 无标题
///(回退首条用户消息)、telegram 启动面、精简形状 tool_calls(无 id,按顺位回填)、
@@ -437,6 +459,103 @@ pub fn build_antigravity_db(path: &Path) {
.expect("populate antigravity fixture db");
}
+/// Cursor IDE `state.vscdb` 最小同构库:VS Code 的两张 KV 表 + 2026 新增的
+/// composerHeaders 索引表。
+/// - `cide-0001`:正常会话。气泡顺序只在 `fullConversationHeadersOnly` 里,
+/// KV 的 key 序(随机 UUID)与它**故意不一致**——照 key 序读会打乱对话,
+/// 这条是防回归的主要断言。含 thinking 气泡、工具气泡(rawArgs 形态)、
+/// **只有 params 没有 rawArgs 的终端气泡**(实测占工具调用的 11%,且
+/// 结果是 `{"output":…}` 对象而非字符串)、空壳流式气泡
+/// (Cursor 每个分片都落一条,绝大多数没有 text),以及一条顺序表里有、
+/// KV 里已被清理的气泡。
+/// - `cide-0002`:`name` 为空且无 lastUpdatedAt,验证标题回退首条用户消息、
+/// updated_at 回退末条气泡的 ISO createdAt。
+/// - `cide-0003`:零气泡的草稿 composer,不进列表。
+/// - `cide-0004`:子代理会话,composerHeaders 给出 parentComposerId。
+pub fn build_cursor_ide_db(path: &Path) {
+ let conn = rusqlite::Connection::open(path).expect("create cursor ide fixture db");
+ conn.execute_batch(
+ r#"
+ CREATE TABLE ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB);
+ CREATE TABLE cursorDiskKV (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB);
+ CREATE TABLE composerHeaders (
+ composerId TEXT PRIMARY KEY, workspaceId TEXT, createdAt INTEGER,
+ lastUpdatedAt INTEGER, isArchived INTEGER, isSubagent INTEGER,
+ recency INTEGER, checkpointAt INTEGER, value TEXT, subagentTypeName TEXT
+ );
+
+ INSERT INTO cursorDiskKV (key, value) VALUES
+ ('composerData:cide-0001',
+ '{"_v":18,"composerId":"cide-0001","name":"Cursor IDE QR fix",
+ "createdAt":1786300000000,"lastUpdatedAt":1786300600000,
+ "workspaceIdentifier":{"id":"ws1","uri":{"fsPath":"/Users/tester/Github/wakefx","path":"/Users/tester/Github/wakefx","scheme":"file"}},
+ "trackedGitRepos":[],
+ "fullConversationHeadersOnly":[
+ {"bubbleId":"zz-user-1","type":1,"createdAt":"2026-08-09T10:00:05.000Z"},
+ {"bubbleId":"aa-think-1","type":2,"createdAt":"2026-08-09T10:00:08.000Z"},
+ {"bubbleId":"mm-tool-1","type":2,"createdAt":"2026-08-09T10:00:09.000Z"},
+ {"bubbleId":"nn-term-1","type":2,"createdAt":"2026-08-09T10:00:09.500Z"},
+ {"bubbleId":"bb-empty-1","type":2,"createdAt":"2026-08-09T10:00:10.000Z"},
+ {"bubbleId":"cc-gone-1","type":2,"createdAt":"2026-08-09T10:00:11.000Z"},
+ {"bubbleId":"kk-final-1","type":2,"createdAt":"2026-08-09T10:00:12.000Z"}]}'),
+ ('bubbleId:cide-0001:zz-user-1',
+ '{"_v":3,"type":1,"bubbleId":"zz-user-1","createdAt":"2026-08-09T10:00:05.000Z",
+ "text":"Cursor IDE 看看二维码扫描为何闪退,是不是 useEffect() 的问题"}'),
+ ('bubbleId:cide-0001:aa-think-1',
+ '{"_v":3,"type":2,"bubbleId":"aa-think-1","createdAt":"2026-08-09T10:00:08.000Z",
+ "text":"","thinking":{"text":"先查 effect 依赖和清理函数"}}'),
+ ('bubbleId:cide-0001:mm-tool-1',
+ '{"_v":3,"type":2,"bubbleId":"mm-tool-1","createdAt":"2026-08-09T10:00:09.000Z","text":"",
+ "toolFormerData":{"toolCallId":"call_ide_1","name":"grep","status":"completed",
+ "rawArgs":"{\"pattern\":\"useEffect\"}",
+ "result":"src/QrScanner.tsx: useEffect(() => watch())"}}'),
+ ('bubbleId:cide-0001:nn-term-1',
+ '{"_v":3,"type":2,"bubbleId":"nn-term-1","createdAt":"2026-08-09T10:00:09.500Z","text":"",
+ "toolFormerData":{"toolCallId":"call_ide_2","name":"run_terminal_command_v2","status":"completed",
+ "rawArgs":"",
+ "params":{"command":"cargo test -p wakefx","cwd":""},
+ "result":{"output":"test result: ok. 3 passed","rejected":false}}}'),
+ ('bubbleId:cide-0001:bb-empty-1',
+ '{"_v":3,"type":2,"bubbleId":"bb-empty-1","createdAt":"2026-08-09T10:00:10.000Z","text":""}'), ('bubbleId:cide-0001:kk-final-1',
+ '{"_v":3,"type":2,"bubbleId":"kk-final-1","createdAt":"2026-08-09T10:00:12.000Z",
+ "text":"找到泄漏点,已在清理回调里停止扫描。"}'),
+
+ ('composerData:cide-0002',
+ '{"_v":13,"composerId":"cide-0002","name":"",
+ "createdAt":1786310000000,
+ "fullConversationHeadersOnly":[
+ {"bubbleId":"q1","type":1},
+ {"bubbleId":"q2","type":2,"createdAt":"2026-08-09T11:00:20.000Z"}]}'),
+ ('bubbleId:cide-0002:q1',
+ '{"_v":3,"type":1,"bubbleId":"q1","createdAt":"2026-08-09T11:00:10.000Z",
+ "text":"空 name 会话的兜底标题应取这句"}'),
+ ('bubbleId:cide-0002:q2',
+ '{"_v":3,"type":2,"bubbleId":"q2","createdAt":"2026-08-09T11:00:20.000Z","text":"好的。"}'),
+
+ ('composerData:cide-0003',
+ '{"_v":18,"composerId":"cide-0003","name":"Draft never sent",
+ "createdAt":1786320000000,"fullConversationHeadersOnly":[]}'),
+
+ ('composerData:cide-0004',
+ '{"_v":18,"composerId":"cide-0004","name":"Explore subagent",
+ "createdAt":1786330000000,"lastUpdatedAt":1786330100000,
+ "workspaceIdentifier":{"id":"ws1","uri":{"fsPath":"/Users/tester/Github/wakefx","path":"/Users/tester/Github/wakefx","scheme":"file"}},
+ "fullConversationHeadersOnly":[{"bubbleId":"s1","type":1}]}'),
+ ('bubbleId:cide-0004:s1',
+ '{"_v":3,"type":1,"bubbleId":"s1","createdAt":"2026-08-09T12:00:00.000Z","text":"child task"}');
+
+ INSERT INTO composerHeaders
+ (composerId, workspaceId, createdAt, lastUpdatedAt, isArchived, isSubagent, recency, checkpointAt, value, subagentTypeName)
+ VALUES
+ ('cide-0001','ws1',1786300000000,1786300600000,0,0,1786300600000,NULL,
+ '{"type":"head","composerId":"cide-0001","name":"Cursor IDE QR fix"}',NULL),
+ ('cide-0004','ws1',1786330000000,1786330100000,0,1,1786330100000,NULL,
+ '{"type":"head","composerId":"cide-0004","name":"Explore subagent","subagentInfo":{"subagentType":3,"parentComposerId":"cide-0001","subagentTypeName":"explore"}}','explore');
+ "#,
+ )
+ .expect("populate cursor ide fixture db");
+}
+
/// 让本进程(及其子进程)的全部 adapter 只看这个假 HOME:WAKE_HOME 是 adapter
/// 侧的统一改道开关,三端一致;HOME 仍设一份供其他 POSIX 依赖(Windows 上 dirs
/// 不看 HOME,单设它等于没设)。再清掉各家的 env 根覆盖——开发机或 CI 上设了
@@ -452,6 +571,7 @@ pub fn isolate_home(home: &Path) {
pub fn clear_agent_env_overrides() {
for var in [
"XDG_DATA_HOME",
+ "XDG_CONFIG_HOME",
"CODEX_HOME",
"QODER_CONFIG_DIR",
"HERMES_HOME",