use crate::ingest::{Turn, TurnTokens};
use rusqlite::Connection;
use serde_json::Value;
use std::path::Path;
const TYPE_USER: i64 = 1;
const TYPE_ASSISTANT: i64 = 2;
pub struct CursorSession {
pub composer_id: String,
pub name: Option<String>,
pub created_at: i64,
pub last_updated_at: i64,
}
pub fn list_sessions(db_path: &Path) -> Vec<CursorSession> {
let Ok(conn) = open_readonly(db_path) else {
return vec![];
};
let mut stmt = match conn.prepare(
"SELECT CAST(key AS TEXT), CAST(value AS TEXT) FROM cursorDiskKV \
WHERE key >= 'composerData:' AND key < 'composerData;'",
) {
Ok(s) => s,
Err(_) => return vec![],
};
let rows = stmt.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)));
let Ok(rows) = rows else {
return vec![];
};
let mut out = vec![];
for (key, json) in rows.flatten() {
let Some(id) = key.strip_prefix("composerData:") else {
continue;
};
let Ok(v) = serde_json::from_str::<Value>(&json) else {
continue;
};
out.push(CursorSession {
composer_id: id.to_string(),
name: v.get("name").and_then(|n| n.as_str()).map(str::to_string),
created_at: v.get("createdAt").and_then(|c| c.as_i64()).unwrap_or(0),
last_updated_at: v.get("lastUpdatedAt").and_then(|c| c.as_i64()).unwrap_or(0),
});
}
out.sort_by_key(|s| s.created_at);
out
}
pub fn parse_session(db_path: &Path, composer_id: &str) -> Vec<Turn> {
let Ok(conn) = open_readonly(db_path) else {
return vec![];
};
let composer = match read_kv(&conn, &format!("composerData:{composer_id}")) {
Some(v) => v,
None => return vec![],
};
let headers = composer
.get("fullConversationHeadersOnly")
.and_then(|h| h.as_array())
.cloned()
.unwrap_or_default();
let mut turns: Vec<Turn> = vec![];
let mut cur: Option<Turn> = None;
for header in &headers {
let Some(bubble_id) = header.get("bubbleId").and_then(|b| b.as_str()) else {
continue;
};
let bubble = match read_kv(&conn, &format!("bubbleId:{composer_id}:{bubble_id}")) {
Some(b) => b,
None => continue,
};
let btype = bubble
.get("type")
.or_else(|| header.get("type"))
.and_then(|t| t.as_i64())
.unwrap_or(0);
let text = bubble.get("text").and_then(|t| t.as_str()).unwrap_or("");
let tokens = tokens_from(bubble.get("tokenCount"));
match btype {
TYPE_USER => {
if let Some(t) = cur.take() {
turns.push(t);
}
cur = Some(Turn {
user_text: text.to_string(),
assistant_text: String::new(),
tool_calls: vec![],
tool_calls_raw: vec![],
tokens,
model: String::new(),
timestamp: String::new(), cwd: None,
git_branches: vec![],
git_commit: None,
});
}
TYPE_ASSISTANT => {
let t = cur.get_or_insert_with(empty_turn);
if !text.is_empty() {
if !t.assistant_text.is_empty() {
t.assistant_text.push_str("\n\n");
}
t.assistant_text.push_str(text);
}
t.tokens.add(&tokens);
}
_ => {} }
}
if let Some(t) = cur.take() {
turns.push(t);
}
turns
}
fn empty_turn() -> Turn {
Turn {
user_text: String::new(),
assistant_text: String::new(),
tool_calls: vec![],
tool_calls_raw: vec![],
tokens: TurnTokens::default(),
model: String::new(),
timestamp: String::new(),
cwd: None,
git_branches: vec![],
git_commit: None,
}
}
fn tokens_from(v: Option<&Value>) -> TurnTokens {
let Some(v) = v else {
return TurnTokens::default();
};
let g = |k: &str| v.get(k).and_then(|x| x.as_u64()).unwrap_or(0);
TurnTokens {
input: g("inputTokens"),
output: g("outputTokens"),
..Default::default()
}
}
fn read_kv(conn: &Connection, key: &str) -> Option<Value> {
let json: String = conn
.query_row(
"SELECT CAST(value AS TEXT) FROM cursorDiskKV WHERE key = ?1",
[key],
|r| r.get(0),
)
.ok()?;
serde_json::from_str(&json).ok()
}
fn open_readonly(path: &Path) -> rusqlite::Result<Connection> {
let conn = Connection::open(path)?;
conn.pragma_update(None, "query_only", true)?;
Ok(conn)
}
#[cfg(test)]
mod tests {
use super::*;
fn fixture() -> (tempfile::TempDir, std::path::PathBuf) {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("state.vscdb");
let conn = Connection::open(&path).unwrap();
conn.execute(
"CREATE TABLE cursorDiskKV (key TEXT PRIMARY KEY, value BLOB)",
[],
)
.unwrap();
let put = |k: &str, v: Value| {
conn.execute(
"INSERT INTO cursorDiskKV (key, value) VALUES (?1, ?2)",
rusqlite::params![k, serde_json::to_vec(&v).unwrap()],
)
.unwrap();
};
put(
"composerData:c1",
serde_json::json!({
"name": "Test chat", "createdAt": 1000,
"fullConversationHeadersOnly": [
{ "bubbleId": "b1", "type": 1 },
{ "bubbleId": "b2", "type": 2 },
{ "bubbleId": "b3", "type": 1 },
]
}),
);
put(
"bubbleId:c1:b1",
serde_json::json!({ "type": 1, "text": "hello",
"tokenCount": { "inputTokens": 10, "outputTokens": 0 } }),
);
put(
"bubbleId:c1:b2",
serde_json::json!({ "type": 2, "text": "hi there",
"tokenCount": { "inputTokens": 0, "outputTokens": 5 } }),
);
put(
"bubbleId:c1:b3",
serde_json::json!({ "type": 1, "text": "thanks" }),
);
(dir, path)
}
#[test]
fn lists_and_parses_a_session() {
let (_d, path) = fixture();
let sessions = list_sessions(&path);
assert_eq!(sessions.len(), 1);
assert_eq!(sessions[0].composer_id, "c1");
assert_eq!(sessions[0].name.as_deref(), Some("Test chat"));
let turns = parse_session(&path, "c1");
assert_eq!(turns.len(), 2);
assert_eq!(turns[0].user_text, "hello");
assert_eq!(turns[0].assistant_text, "hi there");
assert_eq!(turns[0].tokens.input, 10);
assert_eq!(turns[0].tokens.output, 5);
assert_eq!(turns[1].user_text, "thanks");
}
#[test]
fn tolerates_a_missing_db() {
assert!(list_sessions(Path::new("/nonexistent/state.vscdb")).is_empty());
assert!(parse_session(Path::new("/nonexistent/state.vscdb"), "c1").is_empty());
}
}