All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
use super::parse_utils::*;
use super::{cursor_ide, AgentAdapter};
use crate::models::*;
use anyhow::Result;
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
use std::io::BufReader;
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,也不记模型——
/// 两样都优先从同一会话的 IDE 元数据借(`cursor_ide::composer_facts`),路径缺失时从
/// slug 目录名还原。纯 CLI 会话在 IDE 库里没有记录,模型就空着;token 转录这一路不给。
///
/// **同一家的另一个源**:IDE 面板(Chat/Composer)的会话正文在
/// `globalStorage/state.vscdb`,由 cursor_ide.rs 读。某些 Cursor 版本的 IDE
/// 会话在本源只留 `{"type":"turn_ended"}` 空壳,枚举时按 `is_turn_marker_only`
/// 跳过;转录带正文时两源各有一份,scanner 的副本裁决按 `dedup_rank` 固定让
/// 本源胜出,正文仍从转录读取。
pub struct CursorAdapter {
root: PathBuf,
metadata_db: Option<PathBuf>,
/// 指令文件(项目根下的 .cursor/rules、.cursorrules)与自定义来源按指纹缓存,每轮扫描只 stat
memories: super::MemoryCache,
/// `~/.cursor`;直接选中 projects 目录的自定义根没有
home: Option<PathBuf>,
}
impl CursorAdapter {
pub fn new() -> Self {
let home = super::home_dir().unwrap_or_default().join(".cursor");
Self {
root: home.join("projects"),
metadata_db: Some(cursor_ide::default_db_path()),
memories: super::MemoryCache::new(),
home: Some(home),
}
}
/// 同一个会话在 IDE 库里的 composer(只有默认实例有 IDE 库;自定义根也用于远程缓存,
/// 不能混用本机的)。新版 Cursor 给 IDE 会话也写转录、转录胜出,项目与模型得从这份借
fn composer_facts(&self, r: &SessionFileRef) -> cursor_ide::ComposerFacts {
self.metadata_db
.as_deref()
.and_then(|db| cursor_ide::composer_facts(db, std::iter::once(r.native_id.as_str())))
.and_then(|mut facts| facts.remove(&r.native_id))
.unwrap_or_default()
}
fn build_meta(&self, r: &SessionFileRef, p: &CursorParse) -> SessionMeta {
let facts = self.composer_facts(r);
let cwd = resolve_project_path(r, facts.project.as_ref());
let spawned = subagent_parent_dir(Path::new(&r.file_path)).is_some();
// 子代理的 composer 名字是派它时写的任务说明(IDE 里跑的才有),比它收到的整段提示好认
let title = facts
.name
.filter(|_| spawned)
.or_else(|| title_from_messages(&p.messages))
.unwrap_or_else(|| UNTITLED.to_string());
SessionMeta {
key: format!("cursor:{}", r.native_id),
host: String::new(),
id: r.native_id.clone(),
agent: AgentId::Cursor,
title,
project_path: cwd.clone(),
project_name: project_name_of(&cwd),
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
},
message_count: p
.messages
.iter()
.filter(|m| m.kind == MessageKind::Text)
.count() as i64,
size_bytes: r.size,
git_branch: None,
model: facts.model,
tokens_used: None,
archived: false,
source: None,
spawned,
favorite: false,
pinned: false,
}
}
}
/// Cursor 用 `-` 表示分隔符、连字符和空格;优先保留原有路径匹配。
fn decode_existing_slug(base: PathBuf, slug: &str) -> Option<PathBuf> {
fn dfs(base: PathBuf, parts: &[&str]) -> Option<PathBuf> {
if parts.is_empty() {
return Some(base);
}
let mut seg = String::new();
for i in 0..parts.len() {
if i > 0 {
seg.push('-');
}
seg.push_str(parts[i]);
let path = base.join(&seg);
if path.is_dir() {
if let Some(hit) = dfs(path, &parts[i + 1..]) {
return Some(hit);
}
}
}
None
}
if slug.is_empty() {
return Some(base);
}
let parts: Vec<&str> = slug.split('-').collect();
if let Some(path) = dfs(base.clone(), &parts) {
return Some(path);
}
let entries = fs::read_dir(&base).ok()?;
let mut candidates = Vec::new();
for entry in entries.flatten() {
let raw = entry.file_name().to_string_lossy().to_string();
let encoded = raw.replace(' ', "-");
let rest = if slug == encoded {
Some("")
} else {
slug.strip_prefix(&encoded)
.and_then(|s| s.strip_prefix('-'))
};
if let Some(rest) = rest {
let path = entry.path();
if path.is_dir() {
candidates.push((encoded.len(), raw.contains(' '), raw, path, rest));
}
}
}
candidates.sort_by(|a, b| {
a.0.cmp(&b.0)
.then_with(|| a.1.cmp(&b.1))
.then_with(|| a.2.cmp(&b.2))
});
for (_, _, _, path, rest) in candidates {
if let Some(hit) = decode_existing_slug(path, rest) {
return Some(hit);
}
}
None
}
fn decode_slug(slug: &str) -> String {
decode_existing_slug(PathBuf::from("/"), slug)
.map(|p| p.to_string_lossy().to_string())
.unwrap_or_else(|| format!("/{}", slug.replace('-', "/")))
}
/// "Thursday, Jul 23, 2026, 4:00 PM (UTC+8)" → epoch ms,解析失败 = 0
fn cursor_ts_ms(s: &str) -> i64 {
(|| -> Option<i64> {
let (dt_part, tz_part) = s.rsplit_once(" (")?;
let naive =
chrono::NaiveDateTime::parse_from_str(dt_part.trim(), "%A, %b %d, %Y, %I:%M %p")
.ok()?;
let off = tz_part.trim_end_matches(')').strip_prefix("UTC")?;
let (sign, rest) = match off.as_bytes().first()? {
b'+' => (1i32, &off[1..]),
b'-' => (-1i32, &off[1..]),
_ => (1i32, off),
};
let secs = match rest.split_once(':') {
Some((h, m)) => h.parse::<i32>().ok()? * 3600 + m.parse::<i32>().ok()? * 60,
None => rest.parse::<i32>().ok()? * 3600,
};
let offset = chrono::FixedOffset::east_opt(sign * secs)?;
use chrono::TimeZone;
Some(
offset
.from_local_datetime(&naive)
.single()?
.timestamp_millis(),
)
})()
.unwrap_or(0)
}
struct CursorParse {
messages: Vec<TranscriptMessage>,
created_at: i64,
updated_at: i64,
unknown_lines: u32,
dispatches: Vec<Dispatch>,
}
/// 主线里派子代理的调用(Task)。转录里的工具调用没有 id,详情页的跳转靠这两样对上
/// subagents/ 里的转录:头一回派的 `prompt` 就是子代理收到的第一句,接着派的 `resume` 直接
/// 点名子代理
struct Dispatch {
/// 调用所在的消息,与它在那条消息里的位置
message: usize,
call: usize,
prompt: Option<String>,
resume: Option<String>,
description: Option<String>,
agent_type: Option<String>,
}
#[derive(Default)]
struct PendingAssistant {
content: ParsedContent,
tool_calls: Vec<ToolCallView>,
timestamp: Option<i64>,
}
fn flush_assistant(pending: &mut Option<PendingAssistant>, messages: &mut Vec<TranscriptMessage>) {
let Some(p) = pending.take() else { return };
let ParsedContent { text, images } = p.content;
if text.is_empty() && p.tool_calls.is_empty() && images.is_empty() {
return;
}
let (clipped, truncated) = clip(&text, MAX_MSG_TEXT);
messages.push(TranscriptMessage {
seq: 0,
role: Role::Assistant,
kind: MessageKind::Text,
text: clipped,
truncated,
tool_calls: p.tool_calls,
thinking: None,
timestamp: p.timestamp,
model: None,
images,
});
}
fn parse_cursor_jsonl(path: &Path, decode_images: bool) -> Result<CursorParse> {
let _image_budget = transcript_image_decode_budget(decode_images);
let file = fs::File::open(path)?;
let reader = BufReader::with_capacity(1 << 20, file);
let mut messages: Vec<TranscriptMessage> = Vec::new();
let mut pending: Option<PendingAssistant> = None;
let mut created_at = 0i64;
let mut updated_at = 0i64;
let mut unknown_lines = 0u32;
// 读不出/不是 JSON 的行(截断、损坏),与"认得出 JSON 但类型未知"分开计
let mut malformed_lines = 0u32;
let mut dispatches = Vec::new();
for row in jsonl_values(reader) {
let Some(row) = row? else {
unknown_lines += 1;
malformed_lines += 1;
continue;
};
let Some(role) = row.get("role").and_then(|v| v.as_str()) else {
match row.get("type").and_then(|v| v.as_str()) {
Some("turn_ended") => flush_assistant(&mut pending, &mut messages),
_ => unknown_lines += 1,
}
continue;
};
let blocks = row
.get("message")
.and_then(|m| m.get("content"))
.and_then(|c| c.as_array())
.cloned()
.unwrap_or_default();
match role {
"user" => {
flush_assistant(&mut pending, &mut messages);
let mut parsed_message = ParsedContent::default();
let mut ts = 0i64;
for b in &blocks {
match b.get("type").and_then(|v| v.as_str()) {
Some("text") => {
let Some(raw) = b.get("text").and_then(|v| v.as_str()) else {
continue;
};
if let Some(t) = extract_tag(raw, "timestamp") {
let parsed = cursor_ts_ms(&t);
if parsed > 0 {
ts = parsed;
}
}
parsed_message.push_text(&user_query(raw));
}
_ if is_image_part(b) => {
let parsed = content_parts(b, decode_images);
parsed_message.append(parsed);
}
_ => {}
}
}
let ParsedContent { text, images } = parsed_message;
if text.trim().is_empty() && images.is_empty() {
continue;
}
if ts > 0 {
if created_at == 0 {
created_at = ts;
}
updated_at = updated_at.max(ts);
}
let mut message = text_msg(Role::User, &text, ts);
message.images = images;
messages.push(message);
}
"assistant" => {
// Cursor 逐块落行且无消息 id,连续 assistant 行并成一条,turn_ended/user 处 flush
let p = pending.get_or_insert_with(PendingAssistant::default);
for b in &blocks {
match b.get("type").and_then(|v| v.as_str()) {
Some("text") => {
if let Some(t) = b.get("text").and_then(|v| v.as_str()) {
if !t.trim().is_empty() {
p.content.push_text(t);
}
}
}
Some("tool_use") => {
let input = b.get("input").cloned().unwrap_or(Value::Null);
let name = b.get("name").and_then(|v| v.as_str()).unwrap_or("tool");
let text = |key: &str| optional_string(input.get(key));
let (prompt, resume) = (text("prompt"), text("resume"));
if prompt.is_some() || resume.is_some() {
// 这条助手消息还没落进 messages:flush 时它就排在这个位置
dispatches.push(Dispatch {
message: messages.len(),
call: p.tool_calls.len(),
prompt,
resume,
description: text("description"),
agent_type: text("subagent_type"),
});
}
// transcript 不落盘工具结果,output 恒 None
p.tool_calls.push(tool_call_view(
String::new(),
name,
&input,
None,
false,
));
}
_ if is_image_part(b) => {
let parsed = content_parts(b, decode_images);
p.content.append(parsed);
}
_ => {}
}
}
}
_ => unknown_lines += 1,
}
}
flush_assistant(&mut pending, &mut messages);
assign_seq(&mut messages);
// 一条消息都没解出来、却有坏行:这是截断/损坏的转录(如只剩 `{"role":`,
// 它过得了 is_turn_marker_only 的空壳判定),不是空会话。按失败报出去,
// scanner 才会按裁决顺位回退到 IDE 库那份副本;返回 Ok 零消息会让
// dedup_rank 靠前的坏转录压过完整副本(2026-09-15 Codex review)
if messages.is_empty() && malformed_lines > 0 {
anyhow::bail!("no messages parsed, {malformed_lines} unreadable line(s)");
}
Ok(CursorParse {
messages,
created_at,
updated_at,
unknown_lines,
dispatches,
})
}
/// 用户文字块里人打的那句:`<user_query>` 壳里的话,没有壳的原样(解析与 `first_query` 共用,
/// 对派活调用要逐字相同)
fn user_query(raw: &str) -> String {
extract_tag(raw, "user_query").unwrap_or_else(|| raw.to_string())
}
/// 子代理收到的第一句:第一条用户行里人打的话,与解析出来的那条用户消息同一个取法
fn first_query(path: &Path) -> Option<String> {
let file = fs::File::open(path).ok()?;
for row in jsonl_values(BufReader::new(file)) {
let Ok(Some(row)) = row else { continue };
if row.get("role").and_then(Value::as_str) != Some("user") {
continue;
}
let mut query = ParsedContent::default();
for b in row.pointer("/message/content")?.as_array()? {
if b.get("type").and_then(Value::as_str) == Some("text") {
if let Some(raw) = b.get("text").and_then(Value::as_str) {
query.push_text(&user_query(raw));
}
}
}
return Some(query.text).filter(|q| !q.is_empty());
}
None
}
/// Task 派出去的子代理转录 `agent-transcripts/<父会话>/subagents/<id>.jsonl`(没有 Claude 那样的
/// meta 边车),返回父会话的目录
fn subagent_parent_dir(path: &Path) -> Option<&Path> {
let dir = path.parent()?;
if dir.file_name()? != "subagents" {
return None;
}
let session = dir.parent()?;
(session.parent()?.file_name()? == "agent-transcripts").then_some(session)
}
/// 子代理所在会话的原生 id:会话目录的名字(`AgentAdapter::parent_in_path`)
fn subagent_parent(path: &Path) -> Option<String> {
Some(
subagent_parent_dir(path)?
.file_name()?
.to_string_lossy()
.into_owned(),
)
}
/// 父会话的子代理(subagents/ 里的转录,各自也作为子会话入库)。派它的调用对上了(见
/// `Dispatch`)就挂上跳转,任务说明与类型也从那次调用取;子代理自己下面没有 subagents/,给空
fn link_dispatches(
r: &SessionFileRef,
mainline: &mut [TranscriptMessage],
dispatches: &[Dispatch],
) -> Vec<SidechainInfo> {
let Ok(entries) = fs::read_dir(subagents_dir(r)) else {
return Vec::new();
};
let by_prompt = dispatches
.iter()
.any(|d| d.resume.is_none() && d.prompt.is_some());
let mut sidechains = Vec::new();
let mut firsts = Vec::new();
for path in entries.flatten().map(|entry| entry.path()) {
if path.extension().is_none_or(|ext| ext != "jsonl") {
continue;
}
if let Some(info) = sidechain_info(&path) {
firsts.push(by_prompt.then(|| first_query(&path)).flatten());
sidechains.push(info);
}
}
// 头一回派的按第一句对,只认一对一:同一句话派了两次、或两个子代理收到的第一句相同,分不清
// 谁是谁,不挂跳转——挂了就是几个按钮都指向枚举到的最后一个(Codex review 2026-10-12)
let mut fresh: HashMap<&str, usize> = HashMap::new();
for prompt in dispatches
.iter()
.filter(|d| d.resume.is_none())
.filter_map(|d| d.prompt.as_deref())
{
*fresh.entry(prompt).or_default() += 1;
}
let mut received: HashMap<&str, Option<usize>> = HashMap::new();
for (ix, first) in firsts.iter().enumerate() {
if let Some(first) = first.as_deref() {
received
.entry(first)
.and_modify(|only| *only = None)
.or_insert(Some(ix));
}
}
for d in dispatches {
// 接着派的按 resume 点名,只认它:它的 prompt 是接着说的话,恰好与另一个子代理的第一句
// 相同时会对上两个
let sent = match (&d.resume, d.prompt.as_deref()) {
(Some(resume), _) => sidechains.iter().position(|info| info.id == *resume),
(None, Some(prompt)) if fresh.get(prompt) == Some(&1) => {
received.get(prompt).copied().flatten()
}
_ => None,
};
let Some(info) = sent.map(|ix| &mut sidechains[ix]) else {
continue;
};
if let Some(call) = mainline
.get_mut(d.message)
.and_then(|m| m.tool_calls.get_mut(d.call))
{
call.child_id = info.session_id.clone();
}
info.description = info.description.take().or_else(|| d.description.clone());
info.agent_type = info.agent_type.take().or_else(|| d.agent_type.clone());
}
sidechains
}
fn subagents_dir(r: &SessionFileRef) -> PathBuf {
Path::new(&r.file_path)
.parent()
.unwrap_or(Path::new("."))
.join("subagents")
}
fn resolve_project_path(
r: &SessionFileRef,
metadata: Option<&cursor_ide::ProjectMetadata>,
) -> String {
if let Some(workspace) = metadata.and_then(|m| m.workspace.as_ref()) {
return workspace.clone();
}
// …/projects/<slug>/agent-transcripts/<uuid>/<uuid>.jsonl → slug(子代理的转录再深一层)
let Some(slug) = Path::new(&r.file_path)
.ancestors()
.find(|d| {
d.file_name()
.is_some_and(|name| name == "agent-transcripts")
})
.and_then(|d| d.parent()?.file_name())
else {
return String::new();
};
let slug = slug.to_string_lossy();
// A Git root is not necessarily the workspace. Only let it disambiguate
// spaces/hyphens when the entire path encodes to this transcript's slug.
if let Some(repo) = metadata.and_then(|m| {
m.repositories.iter().find(|path| {
path.trim_start_matches(['/', '\\'])
.replace(['/', '\\', ' '], "-")
== slug
})
}) {
return repo.clone();
}
decode_slug(&slug)
}
/// 这个 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
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
let mut refs = Vec::new();
let Ok(projects) = fs::read_dir(&self.root) else {
return Ok(refs);
};
for project in projects.flatten() {
let transcripts = project.path().join("agent-transcripts");
let Ok(sessions) = fs::read_dir(&transcripts) else {
continue;
};
for session in sessions.flatten() {
// 会话自己的转录,与它派出去的子代理(子会话);判据与监听同一个 file_ref
let dir = session.path();
let files = |dir: &Path| -> Vec<PathBuf> {
fs::read_dir(dir)
.map(|entries| entries.flatten().map(|entry| entry.path()).collect())
.unwrap_or_default()
};
refs.extend(
files(&dir)
.iter()
.chain(&files(&dir.join("subagents")))
.filter_map(|path| self.file_ref(path)),
);
}
}
Ok(refs)
}
fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
// 会话转录 `agent-transcripts/<会话>/<会话>.jsonl` 与子代理转录 `…/<会话>/subagents/<id>.jsonl`。
// 按路径分段判:Windows 的反斜杠路径一样认
if path.parent()?.parent()?.file_name()? != "agent-transcripts"
&& subagent_parent_dir(path).is_none()
{
return None;
}
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> {
// 子代理只有它自己那份转录
if subagent_parent_dir(Path::new(&meta.file_path)).is_some() {
return vec![meta.file_path.clone()];
}
// 会话是 <uuid>/ 整个目录(含 subagents/),删除时整目录进废纸篓
Path::new(&meta.file_path)
.parent()
.map(|d| vec![d.to_string_lossy().to_string()])
.unwrap_or_else(|| vec![meta.file_path.clone()])
}
fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
let parsed = parse_cursor_jsonl(Path::new(&r.file_path), false)?;
let meta = self.build_meta(r, &parsed);
Ok(ParsedSession::derive(
meta,
&parsed.messages,
parsed.unknown_lines,
))
}
fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
let mut parsed = parse_cursor_jsonl(Path::new(&r.file_path), true)?;
let meta = self.build_meta(r, &parsed);
let mut mainline = std::mem::take(&mut parsed.messages);
let sidechains = link_dispatches(r, &mut mainline, &parsed.dispatches);
Ok(ParsedTranscript {
meta,
mainline,
sidechains,
unknown_line_count: parsed.unknown_lines,
})
}
fn load_sidechain(
&self,
r: &SessionFileRef,
sidechain_id: &str,
) -> Result<Vec<TranscriptMessage>> {
let file = subagents_dir(r).join(format!("{sidechain_id}.jsonl"));
if !file.is_file() {
return Ok(Vec::new());
}
Ok(parse_cursor_jsonl(&file, true)?.messages)
}
fn cleanup_paths(&self, meta: &SessionMeta) -> Option<Vec<String>> {
Some(self.session_paths(meta))
}
/// 子代理挂到派它的会话下面:转录在派它的会话目录里,目录名就是那个会话的 id。IDE 库那一路
/// 另报 composer 记的关系
fn parent_in_path(&self) -> Option<super::ParentInPath> {
Some(subagent_parent)
}
fn list_memories(
&self,
sources: &[MemorySource],
projects: &[PathBuf],
) -> Result<Vec<MemoryDoc>> {
// 只有项目指令文件与用户加的自定义来源;trait 默认实现没处放缓存、每轮都重读
super::generic_memory_docs(&self.memories, AgentId::Cursor, sources, projects)
}
fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
// 选中 `~/.cursor` 形态(含 projects/)或直接选中 projects 目录都认
let (root, home) = if dir.join("projects").is_dir() {
(dir.join("projects"), Some(dir))
} else {
(dir, None)
};
Box::new(Self {
root,
// 自定义目录也用于远程缓存,不能混用本机 IDE 元数据。
metadata_db: None,
memories: super::MemoryCache::new(),
home,
})
}
fn homes(&self) -> Vec<PathBuf> {
self.home.iter().cloned().collect()
}
fn data_roots(&self) -> Vec<PathBuf> {
// 空根 = 本条 location 已被用户移除(见 excluding_data_roots)
if self.root.as_os_str().is_empty() {
Vec::new()
} else {
vec![self.root.clone()]
}
}
/// IDE 库里的 composer 可能比转录的最后一次写入还晚落盘:项目与模型每轮扫描都按它
/// 刷一遍,转录没变也跟上(与解析时借的是同一份,不会来回翻)
fn sidecar_updates(
&self,
refs: &[SessionFileRef],
) -> std::collections::HashMap<String, SidecarMeta> {
if refs.is_empty() {
return Default::default();
}
let facts = self.metadata_db.as_deref().and_then(|db| {
cursor_ide::composer_facts(db, refs.iter().map(|r| r.native_id.as_str()))
});
let Some(facts) = facts else {
return Default::default();
};
refs.iter()
.filter_map(|r| {
let f = facts.get(&r.native_id)?;
let update = SidecarMeta {
project: f.project.as_ref().map(|p| resolve_project_path(r, Some(p))),
model: f.model.clone(),
};
Some((r.file_path.clone(), update))
})
.collect()
}
/// 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(),
metadata_db: None,
memories: super::MemoryCache::new(),
home: None,
}))
} 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
}
fn metadata_fixture(data: &str) -> (tempfile::TempDir, CursorAdapter, SessionFileRef) {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("projects");
let session_dir = root.join("wakefx-My-Project/agent-transcripts/session");
fs::create_dir_all(&session_dir).unwrap();
let file = write(
&session_dir,
"session.jsonl",
r#"{"role":"user","message":{"content":[{"type":"text","text":"Transcript body"}]}}"#,
);
let db = dir.path().join("state.vscdb");
let conn = rusqlite::Connection::open(&db).unwrap();
conn.execute_batch("CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value BLOB)")
.unwrap();
conn.execute(
"INSERT INTO cursorDiskKV VALUES ('composerData:session', ?1)",
[data],
)
.unwrap();
let adapter = CursorAdapter {
root,
metadata_db: Some(db),
memories: crate::adapters::MemoryCache::new(),
home: None,
};
let r = adapter.file_ref(&file).unwrap();
(dir, adapter, r)
}
#[test]
fn transcript_prefers_matching_metadata_and_keeps_its_body() {
for data in [
r#"{"workspaceIdentifier":{"uri":{"fsPath":"/wakefx/My Project"}},"trackedGitRepos":[{"repoPath":"/wrong/repo"}]}"#,
r#"{"workspaceIdentifier":{"uri":{"fsPath":""}},"trackedGitRepos":[{"repoPath":"/wakefx/My Project"}]}"#,
r#"{"trackedGitRepos":[{"repoPath":"/wakefx/My Project"}]}"#,
r#"{"trackedGitRepos":[{"repoPath":"/other/repo"},{"repoPath":"/wakefx/My Project"}]}"#,
] {
let (_dir, adapter, r) = metadata_fixture(data);
let session = adapter.parse_session(&r).unwrap();
let transcript = adapter.parse_transcript(&r).unwrap();
for meta in [&session.meta, &transcript.meta] {
assert_eq!(meta.project_path, "/wakefx/My Project");
assert_eq!(meta.project_name, "My Project");
assert_eq!(meta.file_path, r.file_path);
assert_eq!(meta.title, "Transcript body");
}
assert_eq!(session.units.len(), 1);
assert_eq!(transcript.mainline.len(), 1);
assert_eq!(transcript.mainline[0].text, "Transcript body");
}
}
#[test]
fn transcript_falls_back_when_metadata_is_unavailable() {
for data in [
"{}",
r#"{"workspaceIdentifier":{"uri":{"fsPath":""}}}"#,
r#"{"trackedGitRepos":[{"repoPath":"/wakefx"}]}"#,
"{broken",
] {
let (_dir, adapter, r) = metadata_fixture(data);
assert_eq!(
adapter.parse_session(&r).unwrap().meta.project_path,
"/wakefx/My/Project"
);
}
let (dir, mut adapter, mut r) =
metadata_fixture(r#"{"workspaceIdentifier":{"uri":{"fsPath":"/wrong/session"}}}"#);
r.native_id = "unmapped".into();
assert_eq!(
adapter.parse_session(&r).unwrap().meta.project_path,
"/wakefx/My/Project"
);
r.native_id = "session".into();
adapter.metadata_db = Some(dir.path().join("missing.vscdb"));
assert_eq!(
adapter.parse_transcript(&r).unwrap().meta.project_path,
"/wakefx/My/Project"
);
}
#[cfg(unix)]
#[test]
fn repository_root_does_not_replace_existing_subdirectory_workspace() {
let (dir, adapter, mut r) = metadata_fixture("{}");
let repo = dir.path().join("repo");
let project = repo.join("apps/client");
fs::create_dir_all(&project).unwrap();
let slug = project
.to_str()
.unwrap()
.trim_start_matches('/')
.replace('/', "-");
let session_dir = adapter.root.join(slug).join("agent-transcripts/session");
fs::create_dir_all(&session_dir).unwrap();
let file = session_dir.join("session.jsonl");
fs::rename(&r.file_path, &file).unwrap();
r = adapter.file_ref(&file).unwrap();
let conn = rusqlite::Connection::open(adapter.metadata_db.as_ref().unwrap()).unwrap();
conn.execute(
"UPDATE cursorDiskKV SET value = ?1 WHERE key = 'composerData:session'",
[serde_json::json!({"trackedGitRepos": [{"repoPath": repo}]}).to_string()],
)
.unwrap();
assert_eq!(
adapter.parse_session(&r).unwrap().meta.project_path,
project.to_str().unwrap()
);
assert_eq!(
adapter.parse_transcript(&r).unwrap().meta.project_path,
project.to_str().unwrap()
);
}
#[test]
fn metadata_updates_refresh_index_without_reparsing_transcript() {
use crate::db::Store;
use crate::mcp::tools::{self, TranscriptCache};
use crate::scanner::{run_scan, NullEvents, ScanEvents, ScanProgress};
use std::sync::{Arc, Mutex};
#[derive(Default)]
struct Events(Mutex<usize>, Mutex<usize>);
impl ScanEvents for Events {
fn on_progress(&self, progress: &ScanProgress) {
*self.0.lock().unwrap() = progress.total;
}
fn on_sessions_changed(&self) {
*self.1.lock().unwrap() += 1;
}
}
let (dir, adapter, r) = metadata_fixture("{}");
let metadata_db = adapter.metadata_db.clone().unwrap();
let root = adapter.root.clone();
let index = dir.path().join("wake.db");
let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(adapter)];
let store = Arc::new(Store::open(&index).unwrap());
run_scan(&adapters, &store, &NullEvents, false).unwrap();
let before = store.get_session("cursor:session").unwrap().unwrap();
assert_eq!(before.project_path, "/wakefx/My/Project");
let known = store.known_files().unwrap();
let cache = TranscriptCache::default();
let args = serde_json::json!({"key": "cursor:session"});
assert!(
tools::invoke(&store, &adapters, &cache, tools::GET_SESSION, &args)
.unwrap()
.contains("/wakefx/My/Project")
);
// Keep the writer open: the new metadata exists only in WAL, while the
// transcript and the main database's modification time stay unchanged.
let writer = rusqlite::Connection::open(&metadata_db).unwrap();
writer.pragma_update(None, "journal_mode", "WAL").unwrap();
let db_mtime = fs::metadata(&metadata_db).unwrap().modified().unwrap();
writer
.execute(
"UPDATE cursorDiskKV SET value = ?1 WHERE key = 'composerData:session'",
[r#"{"workspaceIdentifier":{"uri":{"fsPath":"/wakefx/My Project"}}}"#],
)
.unwrap();
assert_eq!(
fs::metadata(&metadata_db).unwrap().modified().unwrap(),
db_mtime
);
assert_eq!(
adapters[0]
.file_ref(Path::new(&r.file_path))
.unwrap()
.mtime_ms,
r.mtime_ms
);
let events = Events::default();
run_scan(&adapters, &store, &events, false).unwrap();
let after = store.get_session("cursor:session").unwrap().unwrap();
assert_eq!(after.project_path, "/wakefx/My Project");
assert_eq!(after.project_name, "My Project");
assert_eq!(after.title, before.title);
assert_eq!(after.message_count, before.message_count);
assert_eq!(after.file_path, before.file_path);
assert_eq!(store.known_files().unwrap(), known);
let shown = tools::invoke(&store, &adapters, &cache, tools::GET_SESSION, &args).unwrap();
assert!(
shown.contains("/wakefx/My Project"),
"cached query still has old project: {shown}"
);
assert!(!shown.contains("/wakefx/My/Project"));
assert_eq!(*events.0.lock().unwrap(), 0, "no transcript reparsing");
assert_eq!(
*events.1.lock().unwrap(),
1,
"notify the UI of the new project"
);
let conn = rusqlite::Connection::open(&index).unwrap();
assert_eq!(
conn.query_row(
"SELECT text FROM messages_fts WHERE messages_fts MATCH 'Transcript'",
[],
|row| row.get::<_, String>(0),
)
.unwrap(),
"Transcript body"
);
let unchanged = Events::default();
run_scan(&adapters, &store, &unchanged, false).unwrap();
assert_eq!(
*unchanged.1.lock().unwrap(),
0,
"unchanged metadata is a no-op"
);
drop(store);
// A new process/adapter must also notice later metadata changes.
writer
.execute(
"UPDATE cursorDiskKV SET value = ?1 WHERE key = 'composerData:session'",
[r#"{"workspaceIdentifier":{"uri":{"fsPath":"/wakefx/Relocated Project"}}}"#],
)
.unwrap();
let store = Arc::new(Store::open(&index).unwrap());
let adapters: Vec<Box<dyn AgentAdapter>> = vec![Box::new(CursorAdapter {
root,
metadata_db: Some(metadata_db),
memories: crate::adapters::MemoryCache::new(),
home: None,
})];
let events = Events::default();
run_scan(&adapters, &store, &events, false).unwrap();
assert_eq!(
store
.get_session("cursor:session")
.unwrap()
.unwrap()
.project_path,
"/wakefx/Relocated Project"
);
assert_eq!(*events.0.lock().unwrap(), 0);
// A temporary read/JSON failure must not erase a known project path.
writer
.execute("UPDATE cursorDiskKV SET value = '{broken'", [])
.unwrap();
run_scan(&adapters, &store, &NullEvents, false).unwrap();
assert_eq!(
store
.get_session("cursor:session")
.unwrap()
.unwrap()
.project_path,
"/wakefx/Relocated Project"
);
}
#[test]
fn upgrade_refreshes_existing_cursor_project_without_source_changes() {
use crate::db::Store;
use crate::scanner::{run_scan, NullEvents};
use std::sync::Arc;
let (dir, adapter, r) =
metadata_fixture(r#"{"workspaceIdentifier":{"uri":{"fsPath":"/wakefx/My Project"}}}"#);
let index = dir.path().join("upgrade.db");
let mut old = adapter.parse_session(&r).unwrap();
old.meta.project_path = "/wakefx/My/Project".into();
old.meta.project_name = "Project".into();
{
let store = Store::open(&index).unwrap();
store
.write_session(&old.meta, r.mtime_ms, &old.units)
.unwrap();
}
rusqlite::Connection::open(&index)
.unwrap()
.execute(
"UPDATE schema_meta SET value = '3' WHERE key = 'fts_format'",
[],
)
.unwrap();
let store = Arc::new(Store::open(&index).unwrap());
assert!(store.needs_fts_reindex());
run_scan(&[Box::new(adapter)], &store, &NullEvents, false).unwrap();
assert_eq!(
store
.get_session("cursor:session")
.unwrap()
.unwrap()
.project_path,
"/wakefx/My Project"
);
assert!(!store.needs_fts_reindex());
}
#[test]
fn project_refresh_only_updates_the_unchanged_winning_copy() {
use crate::db::Store;
let (dir, adapter, r) =
metadata_fixture(r#"{"workspaceIdentifier":{"uri":{"fsPath":"/wakefx/My Project"}}}"#);
let parsed = adapter.parse_session(&r).unwrap();
let updates = adapter.sidecar_updates(std::slice::from_ref(&r));
for case in ["unchanged", "newer", "resized", "other-copy", "child"] {
let index = dir.path().join(format!("{case}.db"));
let store = Store::open(&index).unwrap();
let mut saved = parsed.meta.clone();
saved.project_path = "/saved/project".into();
saved.project_name = "project".into();
let mtime = if case == "newer" {
r.mtime_ms + 1
} else {
r.mtime_ms
};
if case == "resized" {
saved.size_bytes += 1;
}
if case == "other-copy" {
saved.file_path.push_str(".copy");
}
store.write_session(&saved, mtime, &parsed.units).unwrap();
if case == "child" {
rusqlite::Connection::open(&index)
.unwrap()
.execute("UPDATE sessions SET parent_key = 'cursor:parent'", [])
.unwrap();
}
let changed = store
.update_sidecar_meta(std::slice::from_ref(&r), &updates)
.unwrap();
assert_eq!(changed, case == "unchanged", "{case}");
let after = store.get_session(&saved.key).unwrap().unwrap();
assert_eq!(
after.project_path,
if changed {
"/wakefx/My Project"
} else {
"/saved/project"
},
"{case}"
);
assert_eq!(after.file_path, saved.file_path);
}
}
#[test]
fn sidecar_refresh_fills_the_model_without_clearing_it() {
use crate::db::Store;
// composer 比转录的最后一次写入还晚落盘:解析那一刻借不到模型,之后每轮扫描的
// 侧档刷新补上;侧档不知道模型时(Auto 档、读不出来)不清掉库里已有的
let (dir, adapter, r) =
metadata_fixture(r#"{"modelConfig":{"modelName":"claude-4.5-sonnet"}}"#);
let parsed = adapter.parse_session(&r).unwrap();
assert_eq!(parsed.meta.model.as_deref(), Some("claude-4.5-sonnet"));
let store = Store::open(&dir.path().join("index.db")).unwrap();
let mut saved = parsed.meta.clone();
saved.model = None;
store
.write_session(&saved, r.mtime_ms, &parsed.units)
.unwrap();
let model = || store.get_session(&saved.key).unwrap().unwrap().model;
let updates = adapter.sidecar_updates(std::slice::from_ref(&r));
assert!(store
.update_sidecar_meta(std::slice::from_ref(&r), &updates)
.unwrap());
assert_eq!(model().as_deref(), Some("claude-4.5-sonnet"));
let unknown =
std::collections::HashMap::from([(r.file_path.clone(), SidecarMeta::default())]);
assert!(!store
.update_sidecar_meta(std::slice::from_ref(&r), &unknown)
.unwrap());
assert_eq!(model().as_deref(), Some("claude-4.5-sonnet"));
}
#[test]
fn custom_root_does_not_use_default_project_metadata() {
let (_dir, adapter, r) =
metadata_fixture(r#"{"workspaceIdentifier":{"uri":{"fsPath":"/local/My Project"}}}"#);
let custom = adapter.with_custom_root(adapter.root.clone());
assert_eq!(
custom.parse_session(&r).unwrap().meta.project_path,
"/wakefx/My/Project"
);
assert_eq!(
custom.parse_transcript(&r).unwrap().meta.project_path,
"/wakefx/My/Project"
);
assert!(custom.sidecar_updates(std::slice::from_ref(&r)).is_empty());
}
#[test]
fn slug_decoder_recovers_existing_directory_with_spaces() {
let dir = tempfile::tempdir().expect("tempdir");
for (name, slug) in [
("My Project", "My-Project"),
("My Project/source-code", "My-Project-source-code"),
] {
let project = dir.path().join(name);
fs::create_dir_all(&project).unwrap();
assert_eq!(
decode_existing_slug(dir.path().to_path_buf(), slug),
Some(project)
);
}
}
#[test]
fn slug_decoder_prefers_literal_hyphen_when_ambiguous() {
for (slug, alternative) in [
("image-translate", "image translate"),
("image-translate-src", "image translate/src"),
] {
let dir = tempfile::tempdir().unwrap();
let literal = dir.path().join(slug);
fs::create_dir(&literal).unwrap();
fs::create_dir_all(dir.path().join(alternative)).unwrap();
assert_eq!(
decode_existing_slug(dir.path().to_path_buf(), slug),
Some(literal)
);
}
}
#[test]
fn slug_decoder_respects_filesystem_case_matching() {
let dir = tempfile::tempdir().unwrap();
fs::create_dir(dir.path().join("Mixed-Case")).unwrap();
let path = dir.path().join("mixed-case");
assert_eq!(
decode_existing_slug(dir.path().to_path_buf(), "mixed-case"),
path.is_dir().then_some(path)
);
}
#[cfg(unix)]
#[test]
fn slug_decoder_does_not_require_parent_read_permission() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
let project = dir.path().join("my-project");
fs::create_dir(&project).unwrap();
fs::set_permissions(dir.path(), fs::Permissions::from_mode(0o111)).unwrap();
let decoded = decode_existing_slug(dir.path().to_path_buf(), "my-project");
fs::set_permissions(dir.path(), fs::Permissions::from_mode(0o700)).unwrap();
assert_eq!(decoded, Some(project));
}
/// 判据必须与文件大小无关。曾经的实现对 >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} 字节处(跨块)也必须命中"
);
}
}
/// 截断成 `{"role":` 的转录过得了空壳判定,却一条消息都解不出:必须按解析
/// 失败报出去,scanner 才会回退到 IDE 库副本,而不是让零消息的坏文件胜出
#[test]
fn truncated_transcript_is_a_parse_failure() {
let dir = tempfile::tempdir().expect("tempdir");
let truncated = write(dir.path(), "truncated.jsonl", "{\"role\":\n");
assert!(!is_turn_marker_only(&truncated), "含 role 字样,不是空壳");
assert!(
parse_cursor_jsonl(&truncated, false).is_err(),
"零消息 + 坏行 = 解析失败"
);
// 有消息就照常成功——尾部一条坏行只计 unknown,不推翻整个会话
let intact = write(
dir.path(),
"intact.jsonl",
"{\"role\":\"user\",\"message\":{\"content\":[{\"type\":\"text\",\"text\":\"hi\"}]}}\n{\"role\":\n",
);
let parsed = parse_cursor_jsonl(&intact, false).expect("有正文的转录照常解析");
assert_eq!(parsed.messages.len(), 1);
assert_eq!(parsed.unknown_lines, 1);
}
/// 读不到的文件不下结论:判为"非空壳"交给解析阶段,
/// 绝不能因为打不开就把一个真会话从索引里抹掉
#[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")
));
}
}