Skip to content

armgit / Wake

Public Imported from GitHub
0

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

Rust
20.5 KB
Raw Blame
//! Devin(Cognition 的 agent,CLI 与 Devin Desktop 共用本地存储):
//! `<数据根>/cli/sessions.db` 全明文 SQLite。数据根服从 XDG——
//! `$XDG_DATA_HOME/devin`,缺省 `~/.local/share/devin`(macOS 同样走 XDG
//! 形态,实测);`~/Library/Application Support/devin` 是桌面 Electron 壳的
//! profile 目录,作为历史候选一并探;Windows 的 Devin Desktop 把库放在
//! `%APPDATA%\devin`(从 `home_dir()` 派生,与 cursor_ide 同一约定:不走
//! `dirs::config_dir()`,否则 `WAKE_HOME` 改道对它无效),同样探。候选按序取
//! 第一个真有库文件的,都没有时回落 XDG 语义下的默认位置(env 候选里真有库
//! 才采信,存在但空的目录不能遮掉默认根——与其他 adapter 同一约定)。
//!
//! `sessions(id,title,working_directory,model,agent_mode,created_at,
//! last_activity_at,hidden,main_chain_id,…)` + `message_nodes(row_id,
//! session_id,node_id,parent_node_id,chat_message,created_at)`——每个会话
//! 一座森林:重试/编辑从中间节点开出侧枝,可见转录是从
//! `sessions.main_chain_id` 这片叶子沿 `parent_node_id` 走回根的那一条链;
//! 叶子缺列(老库)、悬空或走不出根(成环)时退回 `created_at,row_id` 全列。
//! 时间戳全是 unix **秒**(INTEGER)。`hidden = 1` 是 Devin 自己不列的会话
//! (compaction 辅助会话、已删会话),不列。空会话(零正文)不列。
//!
//! `chat_message` 是 JSON:`role` ∈ user/assistant/system/tool,`content`
//! 恒为字符串;assistant 的 `tool_calls` 是 `[{id,name,arguments(对象)}]`,
//! `role="tool"` 行按 `tool_call_id` 回填 output;`thinking` 是对象
//! `{thinking,signature,signature_type}`——signature 是 sealed 二进制签名,
//! 只取 thinking 文本;`metadata` 携带 `is_user_input`(真人输入= true)、
//! `telemetry.source`(`cache_keepalive` 等内部来源)、`generation_model`
//! (逐请求的实发模型,比 sessions.model 权威)与 `metrics`
//! (`input_tokens`/`output_tokens`/`cache_read_tokens`/
//! `cache_creation_tokens`,按主链累计进 tokens_used)。
//!
//! 内部消息归 Meta:`system` 角色(注入上下文)、`telemetry.source` 非
//! `user` 的用户消息(cache_keepalive 心跳)、`is_user_input == false`、
//! 以及 compaction 请求正文("Conversation to summarize:" /
//! "Now summarize the conversation above");assistant 的 `<summary>` 应答
//! 折成 CompactSummary。字段缺席按真人放行(老写端未必有 is_user_input)。
//!
//! resume:`devin --resume <id>`(会话按 cwd 分桶,`devin list` 只列当前
//! 目录,故 resume 在项目目录里跑)。无每会话文件,SessionFileRef 用虚拟
//! 路径 `<db>#<id>`。
use super::parse_utils::*;
use super::sqlite_ro::{
    db_cache_stamp, open_sqlite_ro, strip_virtual_path, table_columns, virtual_path, SqliteRo,
};
use super::AgentAdapter;
use crate::models::*;
use anyhow::{anyhow, Result};
use rusqlite::Connection;
use serde_json::Value;
use std::collections::HashMap;
use std::path::{Path, PathBuf};

/// 会话与正文的唯一来源,相对数据根
const DB_REL: &str = "cli/sessions.db";

/// 数据根下的库文件,按段拼:`join(DB_REL)` 在 Windows 上会留下正斜杠,虚拟路径
/// 与别处按段拼出的同一个库字符串对不上
fn db_in(root: &Path) -> PathBuf {
    root.join(DB_REL.split('/').collect::<PathBuf>())
}

pub struct DevinAdapter {
    db: PathBuf,
    /// 枚举查询带全表相关子查询,按库 mtime 缓存一轮扫描内的重复调用
    rows_cache: MtimeCache<Vec<DevinRow>>,
}

#[derive(Clone)]
struct DevinRow {
    id: String,
    title: String,
    cwd: String,
    model: String,
    created_ms: i64,
    updated_ms: i64,
    /// 主链叶子;老库没有 main_chain_id 列(见模块注释的兜底)
    main_chain_id: Option<i64>,
    /// chat_message 总长——空会话过滤与 SessionFileRef.size 的脏判据(单会话取行时不算)
    content_len: i64,
}

/// ALTER 追加的列各自在不在(初始 schema 的列不用探)
#[derive(Clone, Copy)]
struct DevinSchema {
    hidden: bool,
    main_chain_id: bool,
}

impl DevinSchema {
    fn probe(conn: &Connection) -> Self {
        let sessions = table_columns(conn, "sessions");
        Self {
            hidden: sessions.contains("hidden"),
            main_chain_id: sessions.contains("main_chain_id"),
        }
    }
}

struct DevinNode {
    node_id: i64,
    parent_node_id: Option<i64>,
    chat_message: String,
    created_ms: i64,
}

impl DevinAdapter {
    pub fn new() -> Self {
        let home = super::home_dir().unwrap_or_default();
        let local = home.join(".local").join("share").join("devin");
        let xdg = super::env_dir("XDG_DATA_HOME").map(|d| d.join("devin"));
        let app_support = home
            .join("Library")
            .join("Application Support")
            .join("devin");
        // Windows 的 Devin Desktop: %APPDATA%\devin。Mac/Linux 上该目录不会
        // 存在,无条件作候选无害(与 app_support 同理),也让三平台的契约测试
        // 都能覆盖这条解析
        let appdata = home.join("AppData").join("Roaming").join("devin");
        let hit = xdg
            .iter()
            .chain([&local, &app_support, &appdata])
            .find(|dir| db_in(dir).is_file())
            .cloned();
        let root = hit.unwrap_or_else(|| xdg.unwrap_or(local));
        Self::with_db(db_in(&root))
    }

    fn with_db(db: PathBuf) -> Self {
        Self {
            db,
            rows_cache: MtimeCache::new(),
        }
    }

    fn open(&self) -> Option<SqliteRo> {
        open_sqlite_ro(&self.db, "devin")
    }

    /// 行清单,按库(含 -wal)mtime 缓存;库这一刻读不出交回**上一次读到的**
    /// (空清单会让 scanner 把整家会话当"磁盘已删"清掉),从没读成功过才是 None
    fn rows(&self) -> Option<Vec<DevinRow>> {
        let stamp = db_cache_stamp(&self.db);
        self.rows_cache.get_or_stale(stamp, || {
            let ro = self.open()?;
            query_rows(&ro.conn, DevinSchema::probe(&ro.conn), None).ok()
        })
    }

    fn parse(&self, r: &SessionFileRef) -> Result<(SessionMeta, Decoded)> {
        if Path::new(strip_virtual_path(&r.file_path)) != self.db.as_path() {
            return Err(anyhow!("devin database is outside adapter roots"));
        }
        let ro = self.open().ok_or_else(|| anyhow!("cannot open devin db"))?;
        let schema = DevinSchema::probe(&ro.conn);
        let row = query_rows(&ro.conn, schema, Some(&r.native_id))?
            .into_iter()
            .next()
            .ok_or_else(|| anyhow!("devin session {} not in db", r.native_id))?;
        let nodes = query_nodes(&ro.conn, &r.native_id)?;
        let chain = main_chain(nodes, row.main_chain_id);
        let decoded = decode_nodes(chain, &row.model);
        let meta = build_meta(r, &row, &decoded.messages, decoded.tokens);
        Ok((meta, decoded))
    }
}

fn build_meta(
    r: &SessionFileRef,
    row: &DevinRow,
    messages: &[TranscriptMessage],
    tokens: i64,
) -> SessionMeta {
    let title = session_title(&row.title, false, messages);
    SessionMeta {
        key: format!("devin:{}", row.id),
        host: String::new(),
        id: row.id.clone(),
        agent: AgentId::Devin,
        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: messages
            .iter()
            .filter(|m| m.kind == MessageKind::Text)
            .count() as i64,
        size_bytes: r.size,
        git_branch: None,
        // 同一会话会换模型,取最后一条 assistant 的实发模型;没有消息级记录用会话行
        model: messages
            .iter()
            .rev()
            .find_map(|m| m.model.clone())
            .or_else(|| Some(row.model.clone()).filter(|m| !m.is_empty())),
        tokens_used: (tokens > 0).then_some(tokens),
        archived: false,
        source: None,
        spawned: false,
        favorite: false,
        pinned: false,
    }
}

/// unix 秒 → epoch ms;非正数与溢出都给 0(调用方按"没有时间"处理)
fn secs_to_ms(secs: i64) -> i64 {
    secs.checked_mul(1000).unwrap_or(0).max(0)
}

/// 枚举 / 单会话取行。缺列给默认值:老库不得整家消失。单会话取行时不算
/// chat_message 总长——它只给枚举做空会话过滤与脏判据
fn query_rows(
    conn: &Connection,
    schema: DevinSchema,
    id: Option<&str>,
) -> rusqlite::Result<Vec<DevinRow>> {
    let visible = if schema.hidden {
        "COALESCE(s.hidden, 0) <> 1"
    } else {
        "1"
    };
    let leaf = if schema.main_chain_id {
        "s.main_chain_id"
    } else {
        "NULL"
    };
    let content_len = if id.is_some() {
        "0"
    } else {
        "(SELECT COALESCE(SUM(LENGTH(m.chat_message)), 0) FROM message_nodes m
          WHERE m.session_id = s.id)"
    };
    let sql = format!(
        "SELECT s.id, COALESCE(s.title, ''), COALESCE(s.working_directory, ''),
                COALESCE(s.model, ''), COALESCE(s.created_at, 0),
                COALESCE(s.last_activity_at, s.created_at, 0), {leaf}, {content_len}
         FROM sessions s WHERE {visible} AND (?1 IS NULL OR s.id = ?1)"
    );
    let mut stmt = conn.prepare(&sql)?;
    let rows = stmt.query_map([id], |r| {
        Ok(DevinRow {
            id: r.get(0)?,
            title: r.get(1)?,
            cwd: r.get(2)?,
            model: r.get(3)?,
            created_ms: secs_to_ms(r.get::<_, i64>(4)?),
            updated_ms: secs_to_ms(r.get::<_, i64>(5)?),
            main_chain_id: r.get(6)?,
            content_len: r.get::<_, Option<i64>>(7)?.unwrap_or(0),
        })
    })?;
    rows.collect()
}

fn query_nodes(conn: &Connection, session_id: &str) -> rusqlite::Result<Vec<DevinNode>> {
    let mut stmt = conn.prepare(
        "SELECT node_id, parent_node_id, chat_message, created_at
         FROM message_nodes WHERE session_id = ?1 ORDER BY created_at, row_id",
    )?;
    let rows = stmt.query_map([session_id], |r| {
        Ok(DevinNode {
            node_id: r.get(0)?,
            parent_node_id: r.get(1)?,
            chat_message: r.get(2)?,
            created_ms: secs_to_ms(r.get::<_, i64>(3)?),
        })
    })?;
    rows.collect()
}

/// 可见链:从 main_chain_id 叶子沿 parent_node_id 走回根再反转。走不完
/// (叶子悬空、父节点缺失、成环)一律退回原始顺序全列——宁可多列侧枝
/// 也不让会话正文消失
fn main_chain(rows: Vec<DevinNode>, leaf: Option<i64>) -> Vec<DevinNode> {
    let Some(leaf) = leaf else { return rows };
    let by_id: HashMap<i64, usize> = rows
        .iter()
        .enumerate()
        .map(|(i, n)| (n.node_id, i))
        .collect();
    let Some(&start) = by_id.get(&leaf) else {
        return rows;
    };
    // 先按下标走完整条链,确认走得到根再搬节点
    let mut chain = vec![start];
    let mut cur = start;
    while let Some(parent) = rows[cur].parent_node_id {
        match by_id.get(&parent) {
            // 链不可能比全部节点还长,再长就是成环
            Some(&ix) if chain.len() < rows.len() => {
                chain.push(ix);
                cur = ix;
            }
            _ => return rows,
        }
    }
    let mut slots: Vec<Option<DevinNode>> = rows.into_iter().map(Some).collect();
    chain
        .iter()
        .rev()
        .filter_map(|&ix| slots[ix].take())
        .collect()
}

/// compaction 请求的正文特征(Devin 把摘要写成隐藏辅助会话,也内联进主链)
fn is_compact_request(text: &str) -> bool {
    let t = text.trim_start();
    t.starts_with("Conversation to summarize:") || t.starts_with("Now summarize the conversation")
}

/// 一条 chat_message 是否内部来源:system 角色之外,`telemetry.source` 非
/// `user`(cache_keepalive 心跳)、`is_user_input` 显式 false、compaction
/// 请求正文都归 Meta;字段缺席按真人放行
fn is_internal_user(v: &Value, text: &str) -> bool {
    let meta = v.get("metadata");
    let source = meta
        .and_then(|m| m.pointer("/telemetry/source"))
        .and_then(Value::as_str);
    if source.is_some_and(|s| s != "user") {
        return true;
    }
    if meta
        .and_then(|m| m.get("is_user_input"))
        .and_then(Value::as_bool)
        == Some(false)
    {
        return true;
    }
    is_compact_request(text)
}

/// thinking 字段两种形态:对象 `{thinking,signature,signature_type}`(签名是
/// sealed 二进制,不进索引)或老写端的纯字符串
fn thinking_text(v: &Value) -> Option<String> {
    let t = v.get("thinking")?;
    t.get("thinking")
        .and_then(Value::as_str)
        .or_else(|| t.as_str())
        .map(str::trim)
        .filter(|s| !s.is_empty())
        .map(String::from)
}

fn metric_i64(metrics: &Value, key: &str) -> i64 {
    metrics.get(key).and_then(Value::as_i64).unwrap_or(0)
}

struct Decoded {
    messages: Vec<TranscriptMessage>,
    /// 在消息取舍之外单独累计:content 为空但消耗了 token 的 assistant 收尾节点照样入账
    tokens: i64,
    /// 解不开的 chat_message 与词汇表外的 role:格式漂移的金丝雀
    unknown: u32,
}

/// 主链逐节点解码
fn decode_nodes(chain: Vec<DevinNode>, session_model: &str) -> Decoded {
    let mut messages: Vec<TranscriptMessage> = Vec::new();
    let mut tokens = 0i64;
    let mut unknown = 0u32;
    // tool_call_id → (消息下标, tool_calls 下标)
    let mut by_id: HashMap<String, (usize, usize)> = HashMap::new();
    for node in chain {
        let Ok(v) = serde_json::from_str::<Value>(&node.chat_message) else {
            unknown += 1;
            continue;
        };
        if let Some(metrics) = v.pointer("/metadata/metrics") {
            tokens += metric_i64(metrics, "input_tokens")
                + metric_i64(metrics, "output_tokens")
                + metric_i64(metrics, "cache_read_tokens")
                + metric_i64(metrics, "cache_creation_tokens");
        }
        match v.get("role").and_then(Value::as_str) {
            Some("user") => {
                let text = v.get("content").and_then(Value::as_str).unwrap_or_default();
                if text.trim().is_empty() {
                    continue;
                }
                let mut msg = text_msg(Role::User, text, node.created_ms);
                if is_internal_user(&v, text) {
                    msg.kind = MessageKind::Meta;
                }
                messages.push(msg);
            }
            Some("assistant") => {
                let text = v.get("content").and_then(Value::as_str).unwrap_or_default();
                let thinking = thinking_text(&v);
                let calls: Vec<ToolCallView> = v
                    .get("tool_calls")
                    .and_then(Value::as_array)
                    .map(|items| {
                        items
                            .iter()
                            .map(|item| {
                                let id = item
                                    .get("id")
                                    .and_then(Value::as_str)
                                    .unwrap_or_default()
                                    .to_string();
                                let name =
                                    item.get("name").and_then(Value::as_str).unwrap_or_default();
                                let args = item.get("arguments").cloned().unwrap_or(Value::Null);
                                tool_call_view(id, name, &args, None, false)
                            })
                            .collect()
                    })
                    .unwrap_or_default();
                if text.trim().is_empty() && calls.is_empty() && thinking.is_none() {
                    continue;
                }
                let mut msg = text_msg(Role::Assistant, text, node.created_ms);
                if text.trim_start().starts_with("<summary>") {
                    msg.kind = MessageKind::CompactSummary;
                }
                msg.thinking = thinking.map(|t| clip(&t, MAX_TOOL_IO).0);
                msg.model = v
                    .pointer("/metadata/generation_model")
                    .and_then(Value::as_str)
                    .map(String::from)
                    .or_else(|| Some(session_model.to_string()).filter(|m| !m.is_empty()));
                let base = messages.len();
                for tc in calls {
                    by_id.insert(tc.id.clone(), (base, msg.tool_calls.len()));
                    msg.tool_calls.push(tc);
                }
                messages.push(msg);
            }
            Some("tool") => {
                let output = v.get("content").and_then(Value::as_str).unwrap_or_default();
                let slot = v
                    .get("tool_call_id")
                    .and_then(Value::as_str)
                    .and_then(|id| by_id.get(id).copied());
                if let Some((mi, ti)) = slot {
                    messages[mi].tool_calls[ti].output = Some(clip(output, MAX_TOOL_IO).0);
                }
            }
            Some("system") => {
                let text = v.get("content").and_then(Value::as_str).unwrap_or_default();
                if text.trim().is_empty() {
                    continue;
                }
                let mut msg = text_msg(Role::System, text, node.created_ms);
                msg.kind = MessageKind::Meta;
                messages.push(msg);
            }
            _ => unknown += 1,
        }
    }
    assign_seq(&mut messages);
    Decoded {
        messages,
        tokens,
        unknown,
    }
}

impl AgentAdapter for DevinAdapter {
    fn agent(&self) -> AgentId {
        AgentId::Devin
    }

    fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
        // 库不在 = 没有会话(Ok 空);库在但从没读成功过 = 不知道,报 Err 让这轮
        // 扫描停下——折成空会让 seen_paths 清理把整家会话当"磁盘已删"删掉
        let rows = match self.rows() {
            Some(rows) => rows,
            None if self.db.is_file() => {
                anyhow::bail!("{} exists but could not be read", self.db.display())
            }
            None => Vec::new(),
        };
        Ok(rows
            .into_iter()
            .filter(|row| row.content_len > 0)
            .map(|row| SessionFileRef {
                agent: AgentId::Devin,
                file_path: virtual_path(&self.db, &row.id),
                native_id: row.id,
                mtime_ms: row.updated_ms,
                size: row.content_len,
            })
            .collect())
    }

    fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
        let (meta, decoded) = self.parse(r)?;
        Ok(ParsedSession::derive(
            meta,
            &decoded.messages,
            decoded.unknown,
        ))
    }

    fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
        let (meta, decoded) = self.parse(r)?;
        Ok(ParsedTranscript {
            meta,
            mainline: decoded.messages,
            sidechains: Vec::new(),
            unknown_line_count: decoded.unknown,
        })
    }

    fn data_roots(&self) -> Vec<PathBuf> {
        vec![self.db.clone()]
    }

    fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
        // 只按路径形状整形、不看存不存在:远程缓存首次同步前目录还没落盘,
        // 判据随目录出现而改判会让先构造的实例指错树。认两种:数据根
        // (<dir>/cli/sessions.db),或直接给到 sessions.db 的孤立库拷贝;
        // 中间层 cli/ 由 normalize_custom_root 在入库前上提到数据根
        let db = if dir.file_name().is_some_and(|n| n == "sessions.db") {
            dir
        } else {
            db_in(&dir)
        };
        Box::new(Self::with_db(db))
    }
}

/// 入库前的归一化(mod.rs 静态分派):用户在目录选择器里选中 `cli/sessions.db`
/// 或 `cli` 层时上提到数据根。判据是纯路径形状——选中的路径以这几层收尾就按
/// 层数上提——不摸文件系统;孤立的库拷贝(父链不长这个样)原样保留
pub fn normalize_custom_root(dir: PathBuf) -> PathBuf {
    for rel in [DB_REL, "cli"] {
        if dir.ends_with(rel) {
            let depth = Path::new(rel).components().count();
            return dir
                .ancestors()
                .nth(depth)
                .map_or_else(|| dir.clone(), Path::to_path_buf);
        }
    }
    dir
}