All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
use super::parse_utils::*;
use super::pi_format::{PiRender, PiRenderOptions};
use super::sqlite_ro::{open_sqlite_ro, strip_virtual_path, virtual_path};
use super::AgentAdapter;
use crate::models::*;
use anyhow::{anyhow, Result};
use serde_json::Value;
use std::collections::{HashMap, HashSet};
use std::fs;
use std::io::BufReader;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
/// OpenClaw(原 Clawdbot/Moltbot):状态目录 `~/.openclaw`(`OPENCLAW_STATE_DIR`
/// 可改道,老装机名 `~/.clawdbot`),会话按 agent 分桶在 `agents/<agentId>/` 下,
/// **两代存储并存、同扫**:
/// - 现版(2026.8+):`agent/openclaw-agent.sqlite`,session_windows(每个
/// session_id 一行,reset/rollover 后旧窗口保留)+ session_nodes(按 session_key
/// 的活跃指针与 label)+ transcript_events(session_id, seq, event_json)——
/// event_json 就是 pi 系 SessionManager 的一行(首行 `{type:"session",cwd}`
/// header,其余带 id/parentId 的树形条目),`session_transcript_active_events`
/// 按 active_position 给出当前可见分支,缺表/缺行时退回"最后一条为叶"回溯。
/// - 旧版:`sessions/<sessionId>.jsonl` 同格式明文,`sessions.json` 是按
/// session_key 的索引(label/model/totalTokens/spawnedBy)。
///
/// 同一会话被 `doctor --fix` 迁进库后旧 jsonl 仍在,同 native_id 双副本由
/// scanner 按 mtime 裁决(不变量 8⑦),这里不做二选一。
/// 消息形状即 pi-ai,渲染核心与 pi.rs 共用(pi_format);OpenClaw 独有的是
/// thinking 块、`runtimeContextCarrier` 归 Meta、compaction/branch_summary/
/// custom_message/session_info 四种条目。
///
/// 派生出来的子代理(`spawnedBy`)与面板上开的子会话(`parentSessionKey`)照常列出,经
/// `parent_links` 挂到父会话下。条目(库里的 entry_json 与旧版 sessions.json 同一个形状)
/// 记了父会话的确切 id(`parentSessionId` / `spawnedBySessionId`)就用它——库里的条目只描述
/// 这个键眼下那一窗,子会话键被复用时旧窗口用它自己那一行记的。只记了会话键的:库里的子会话
/// 挑那个键在它创建时用着的窗口(一个键 reset 之后对应好几个窗口);旧版只知道每个键眼下那
/// 一条,旧版的子会话就取它(旧版 OpenClaw 也是按键跳转)。同一会话两代都有时以库里的为准。
pub struct OpenclawAdapter {
/// `<state dir>/agents`
root: PathBuf,
/// 每库一份窗口行缓存(键 = 库路径),按库(含 -wal)mtime 失效
rows_cache: Mutex<HashMap<PathBuf, Arc<MtimeCache<Arc<Vec<ClawRow>>>>>>,
/// 旧版 sessions.json 索引,每个 sessions 目录一份,按文件 mtime 失效
index_cache: Mutex<HashMap<PathBuf, Arc<MtimeCache<LegacyIndex>>>>,
/// 状态目录(`~/.openclaw` / OPENCLAW_STATE_DIR);直接选中 agents 目录的自定义根没有
home: Option<PathBuf>,
}
/// sessions.json 解析结果:sessionId → (会话键, 条目)
type LegacyIndex = Arc<HashMap<String, (String, Value)>>;
const DB_NAME: &str = "openclaw-agent.sqlite";
/// 转录事件 JSON 的已知非内容类型:静默跳过,表外计 unknown(格式漂移金丝雀)
const KNOWN_SKIP: &[&str] = &[
"session",
"thinking_level_change",
"label",
"custom",
"reset",
];
impl OpenclawAdapter {
pub fn new() -> Self {
let home = super::home_dir().unwrap_or_default();
// OPENCLAW_STATE_DIR 只是候选:里面真有 agents/ 才采信;默认 ~/.openclaw,
// 只装过老版本的机器(无 .openclaw、有 .clawdbot)回落旧名——与上游
// resolveStateDir 的判序一致
let state = super::env_dir("OPENCLAW_STATE_DIR")
.filter(|d| d.join("agents").is_dir())
.unwrap_or_else(|| {
let new = home.join(".openclaw");
let legacy = home.join(".clawdbot");
if !new.exists() && legacy.exists() {
legacy
} else {
new
}
});
Self {
home: Some(state.clone()),
..Self::with_root(state.join("agents"))
}
}
fn with_root(root: PathBuf) -> Self {
Self {
root,
rows_cache: Mutex::new(HashMap::new()),
index_cache: Mutex::new(HashMap::new()),
home: None,
}
}
/// `agents/<agentId>/` 目录(构造时不要求存在,枚举时缺根降级为空)
fn agent_dirs(&self) -> Vec<PathBuf> {
let Ok(entries) = fs::read_dir(&self.root) else {
return Vec::new();
};
let mut dirs: Vec<PathBuf> = entries
.flatten()
.filter(|e| e.file_type().map(|t| t.is_dir()).unwrap_or(false))
.filter(|e| !e.file_name().to_string_lossy().starts_with('.'))
.map(|e| e.path())
.collect();
dirs.sort();
dirs
}
fn rows_cache_of(&self, db: &Path) -> Arc<MtimeCache<Arc<Vec<ClawRow>>>> {
Arc::clone(
self.rows_cache
.lock()
.unwrap()
.entry(db.to_path_buf())
.or_insert_with(|| Arc::new(MtimeCache::new())),
)
}
/// None = 库在却读不出(打不开、查询出错)
fn rows(&self, db: &Path) -> Option<Arc<Vec<ClawRow>>> {
let stamp = super::sqlite_ro::db_cache_stamp(db);
self.rows_cache_of(db).get_or_try_build(stamp, || {
let ro = open_sqlite_ro(db, "openclaw")?;
query_rows(&ro.conn).map(Arc::new)
})
}
/// 旧版 `sessions.json`:按 sessionId 的索引(原文件按会话键键)。没有这个文件是空的,
/// 解不开也按空的算(上游写它是先写临时文件再改名,解不开就是坏了、不会自己好);
/// 在却读不出(I/O)是 None
fn legacy_index(&self, sessions_dir: &Path) -> Option<LegacyIndex> {
let file = sessions_dir.join("sessions.json");
let meta = match fs::metadata(&file) {
Ok(meta) => meta,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return Some(LegacyIndex::default())
}
Err(_) => return None,
};
let cache = Arc::clone(
self.index_cache
.lock()
.unwrap()
.entry(file.clone())
.or_insert_with(|| Arc::new(MtimeCache::new())),
);
cache.get_or_try_build(mtime_ms(&meta), || {
let text = fs::read_to_string(&file).ok()?;
let map = match serde_json::from_str::<Value>(&text) {
Ok(Value::Object(map)) => map,
_ => Default::default(),
};
Some(Arc::new(
map.into_iter()
.filter_map(|(key, v)| {
Some((v.get("sessionId")?.as_str()?.to_string(), (key, v)))
})
.collect(),
))
})
}
fn legacy_hint(&self, path: &Path, native_id: &str) -> RowHint {
let Some(dir) = path.parent() else {
return RowHint::default();
};
let index = self.legacy_index(dir).unwrap_or_default();
// topic 转录 `<sessionId>-topic-<id>.jsonl` 共用父会话的索引项
let base = native_id.split("-topic-").next().unwrap_or(native_id);
let Some((_, v)) = index.get(native_id).or_else(|| index.get(base)) else {
return RowHint::default();
};
let s = |k: &str| v.get(k).and_then(Value::as_str).map(String::from);
RowHint {
label: s("label").or_else(|| s("displayName")),
model: s("model"),
tokens: v.get("totalTokens").and_then(Value::as_i64),
channel: None,
created_ms: 0,
updated_ms: norm_ms(v.get("updatedAt").and_then(Value::as_i64).unwrap_or(0)),
spawned: entry_spawned(v),
}
}
fn build_meta(r: &SessionFileRef, p: &ClawParse, hint: &RowHint) -> SessionMeta {
let title = p
.name
.clone()
.or_else(|| hint.label.clone())
.map(|t| clean_title_candidate(&t))
.filter(|t| !t.is_empty())
.or_else(|| title_from_messages(&p.messages))
.unwrap_or_else(|| UNTITLED.to_string());
SessionMeta {
key: session_key(AgentId::Openclaw, "", &r.native_id),
host: String::new(),
id: r.native_id.clone(),
agent: AgentId::Openclaw,
title,
project_path: p.cwd.clone(),
project_name: project_name_of(&p.cwd),
file_path: r.file_path.clone(),
created_at: [p.created_at, hint.created_ms, r.mtime_ms]
.into_iter()
.find(|t| *t > 0)
.unwrap_or(0),
updated_at: [p.last_ts, hint.updated_ms, r.mtime_ms]
.into_iter()
.find(|t| *t > 0)
.unwrap_or(0),
message_count: p
.messages
.iter()
.filter(|m| m.kind == MessageKind::Text)
.count() as i64,
size_bytes: r.size,
git_branch: None,
model: p
.model
.clone()
.or_else(|| hint.model.clone())
.filter(|m| !m.is_empty()),
tokens_used: p.tokens_used.or(hint.tokens).filter(|t| *t > 0),
archived: false,
// 频道即启动面(telegram/discord/webchat…);cli/空不打徽章
source: hint.channel.clone().filter(|c| !c.is_empty() && c != "cli"),
spawned: hint.spawned,
favorite: false,
pinned: false,
}
}
fn parse(&self, r: &SessionFileRef, decode_images: bool) -> Result<(SessionMeta, ClawParse)> {
let path = Path::new(&r.file_path);
if path.is_file() {
// 旧版 jsonl:整文件即条目流,叶 = 最后一条
let (entries, bad) = read_jsonl_entries(path)?;
let mut p = render(linearize(entries, None), decode_images);
p.unknown_lines += bad;
let hint = self.legacy_hint(path, &r.native_id);
let meta = Self::build_meta(r, &p, &hint);
return Ok((meta, p));
}
let db = Path::new(strip_virtual_path(&r.file_path));
let row = self
.rows(db)
.and_then(|rows| {
rows.iter()
.find(|row| row.session_id == r.native_id)
.cloned()
})
.ok_or_else(|| anyhow!("openclaw session {} not in store", r.native_id))?;
let ro = open_sqlite_ro(db, "openclaw")
.ok_or_else(|| anyhow!("cannot open openclaw store {}", db.display()))?;
let mut stmt = ro.conn.prepare(
"SELECT seq, event_json FROM transcript_events WHERE session_id = ?1 ORDER BY seq",
)?;
let mut entries: Vec<(i64, Value)> = Vec::new();
let mut unknown = 0u32;
for row in stmt.query_map([&r.native_id], |x| {
Ok((x.get::<_, i64>(0)?, x.get::<_, String>(1)?))
})? {
match row
.ok()
.and_then(|(seq, json)| serde_json::from_str::<Value>(&json).ok().map(|v| (seq, v)))
{
Some(entry) => entries.push(entry),
None => unknown += 1,
}
}
// 当前可见分支(按 active_position);表缺失/为空时退回树回溯
let active: Vec<i64> = ro
.conn
.prepare(
"SELECT event_seq FROM session_transcript_active_events
WHERE session_id = ?1 ORDER BY active_position",
)
.and_then(|mut s| {
s.query_map([&r.native_id], |x| x.get::<_, i64>(0))
.map(|it| it.flatten().collect::<Vec<_>>())
})
.unwrap_or_default();
let active_ix = (!active.is_empty()).then(|| {
let by_seq: HashMap<i64, usize> = entries
.iter()
.enumerate()
.map(|(i, (seq, _))| (*seq, i))
.collect();
active
.iter()
.filter_map(|s| by_seq.get(s).copied())
.collect()
});
let values: Vec<Value> = entries.into_iter().map(|(_, v)| v).collect();
let mut p = render(linearize(values, active_ix), decode_images);
p.unknown_lines += unknown;
let meta = Self::build_meta(r, &p, &row.hint);
Ok((meta, p))
}
}
/// 库内一条会话窗口(session_windows ⋈ session_nodes)
#[derive(Clone)]
struct ClawRow {
session_id: String,
session_key: String,
parent: Option<ParentRef>,
event_count: i64,
content_len: i64,
hint: RowHint,
}
/// 库行 / 旧版索引给解析结果补缺的元数据
#[derive(Clone, Default)]
struct RowHint {
label: Option<String>,
model: Option<String>,
tokens: Option<i64>,
channel: Option<String>,
created_ms: i64,
updated_ms: i64,
/// agent 派生出来的子会话(`entry_spawned`);面板上新建的子会话、频道里的话题只记了
/// parentSessionKey,那是用户自己的对话
spawned: bool,
}
/// 条目是 agent 派生出来的:spawn 时写 spawnedBy / spawnedBySessionId;sessions_spawn 起的
/// 可见子会话只记 parentSessionKey,但 spawnDepth 一定 ≥ 1——上游的派生层级只由 spawn 声明,
/// 面板新建、fork、频道话题一律是 0
fn entry_spawned(entry: &Value) -> bool {
["spawnedBy", "spawnedBySessionId"]
.iter()
.any(|key| text_at(entry, key).is_some())
|| entry.get("spawnDepth").and_then(Value::as_i64).unwrap_or(0) > 0
}
/// 子会话指向父会话的线索
#[derive(Clone)]
enum ParentRef {
/// 确切的那一条会话
Session(String),
/// 只有会话键:reset 之后一个键对应好几个窗口,按子会话开始的时间挑
Key(String),
}
impl ParentRef {
/// `entry` 是条目(库里只给这个键眼下那一窗);`own_key` 是库里窗口行自己记的
/// spawned_by / parent_session_key(旧版没有)
fn of(entry: Option<&Value>, own_key: Option<String>) -> Option<Self> {
let s = |k: &str| optional_string(entry?.get(k));
s("parentSessionId")
.or_else(|| s("spawnedBySessionId"))
.map(Self::Session)
.or_else(|| {
own_key
.or_else(|| s("spawnedBy"))
.or_else(|| s("parentSessionKey"))
.map(Self::Key)
})
}
}
/// 上游全部 ms 整数;防御性兼容秒,阈值与 parse_utils::to_epoch_ms 同一条线
fn norm_ms(v: i64) -> i64 {
to_epoch_ms(&Value::from(v))
}
fn query_rows(conn: &rusqlite::Connection) -> Option<Vec<ClawRow>> {
let mut stmt = conn
.prepare(
"SELECT w.session_id, w.spawned_by, w.created_at, w.updated_at,
w.transcript_updated_at, w.started_at, w.model, w.channel, w.display_name,
n.label, n.display_name, n.entry_json,
COUNT(e.seq), COALESCE(SUM(LENGTH(e.event_json)), 0),
COALESCE(MAX(e.created_at), 0), w.session_key, w.parent_session_key
FROM session_windows w
LEFT JOIN session_nodes n ON n.session_key = w.session_key
LEFT JOIN transcript_events e ON e.session_id = w.session_id
GROUP BY w.session_id",
)
.ok()?;
let rows = stmt
.query_map([], |r| {
let session_id: String = r.get(0)?;
let created = norm_ms(r.get::<_, Option<i64>>(2)?.unwrap_or(0));
let started = norm_ms(r.get::<_, Option<i64>>(5)?.unwrap_or(0));
let updated = norm_ms(r.get::<_, Option<i64>>(3)?.unwrap_or(0));
let transcript_updated = norm_ms(r.get::<_, Option<i64>>(4)?.unwrap_or(0));
let last_event = norm_ms(r.get::<_, Option<i64>>(14)?.unwrap_or(0));
let entry: Value = r
.get::<_, Option<String>>(11)?
.and_then(|s| serde_json::from_str(&s).ok())
.unwrap_or(Value::Null);
let entry_str = |k: &str| entry.get(k).and_then(Value::as_str).map(String::from);
let label = r
.get::<_, Option<String>>(9)?
.or(r.get::<_, Option<String>>(10)?)
.or(r.get::<_, Option<String>>(8)?)
.or_else(|| entry_str("label"))
.or_else(|| entry_str("displayName"))
.filter(|s| !s.trim().is_empty());
let model = r
.get::<_, Option<String>>(6)?
.or_else(|| entry_str("model"));
// 只有当前活跃窗口的 entry_json 归它;老窗口的 node 指向新窗口,
// 计数不能张冠李戴
let is_current = entry.get("sessionId").and_then(Value::as_str) == Some(&session_id);
let tokens = is_current
.then(|| entry.get("totalTokens").and_then(Value::as_i64))
.flatten();
let key_at = |ix: usize| {
r.get::<_, Option<String>>(ix)
.map(|key| key.filter(|key| !key.is_empty()))
};
let spawned_by = key_at(1)?;
let spawned = spawned_by.is_some() || (is_current && entry_spawned(&entry));
let own_key = spawned_by.or(key_at(16)?);
Ok(ClawRow {
session_key: r.get(15)?,
parent: ParentRef::of(is_current.then_some(&entry), own_key),
event_count: r.get(12)?,
content_len: r.get(13)?,
hint: RowHint {
label,
model,
tokens,
channel: r.get(7)?,
created_ms: [started, created].into_iter().find(|t| *t > 0).unwrap_or(0),
updated_ms: [transcript_updated, last_event, updated]
.into_iter()
.max()
.unwrap_or(0),
spawned,
},
session_id,
})
})
.ok()?
.collect::<rusqlite::Result<Vec<_>>>()
.ok();
rows
}
/// 旧版会话目录里列得出来的转录:(主干, 路径, metadata)。归档 / 检查点、空文件与不是普通
/// 文件的不算——列表与关系里的 id 映射都按这一份,两边才不会对不上
fn legacy_transcripts(sessions_dir: &Path) -> Vec<(String, PathBuf, fs::Metadata)> {
let Ok(entries) = fs::read_dir(sessions_dir) else {
return Vec::new();
};
entries
.flatten()
.filter_map(|entry| {
let name = entry.file_name().to_string_lossy().to_string();
if !is_legacy_transcript(&name) {
return None;
}
let meta = entry.metadata().ok()?;
if !meta.is_file() || meta.len() == 0 {
return None;
}
let stem = name.strip_suffix(".jsonl").unwrap_or(&name).to_string();
Some((stem, entry.path(), meta))
})
.collect()
}
/// 每个会话 id 对应的列出来的转录主干:带话题的会话转录叫 `<id>-topic-<话题>.jsonl`
/// (上游 resolveSessionTranscriptPathInDir),枚举时 native id 是整个主干;有裸文件名的用它
fn legacy_stems(listed: impl IntoIterator<Item = String>) -> HashMap<String, String> {
let mut stems = HashMap::new();
for stem in listed {
let id = stem.split("-topic-").next().unwrap_or(&stem).to_string();
if id == stem {
stems.insert(id, stem);
} else {
stems.entry(id).or_insert(stem);
}
}
stems
}
/// 会话在 Wake 里的 id:库里有的用库里的,旧版的换成实际列出来的转录主干
fn listed_id<'a>(
id: &'a str,
in_db: &HashSet<&str>,
stems: &'a HashMap<String, String>,
) -> &'a str {
if in_db.contains(id) {
return id;
}
stems.get(id).map_or(id, String::as_str)
}
/// 旧版转录文件名过滤:归档/回滚快照/压缩检查点都不是活会话
fn is_legacy_transcript(name: &str) -> bool {
name.ends_with(".jsonl")
&& !name.starts_with('.')
&& !name.contains(".deleted.")
&& !name.contains(".reset.")
&& !name.contains(".checkpoint.")
}
/// (条目, 坏行数)
fn read_jsonl_entries(path: &Path) -> Result<(Vec<Value>, u32)> {
let file = fs::File::open(path)?;
let reader = BufReader::with_capacity(1 << 20, file);
let mut out = Vec::new();
let mut bad = 0u32;
for row in jsonl_values(reader) {
match row? {
Some(v) => out.push(v),
None => bad += 1,
}
}
Ok((out, bad))
}
/// 树形条目 → 当前分支的线性序列(header 在首位)。`active` 给出(下标)显式
/// 分支时照单;否则以最后一条带 id 的条目为叶沿 parentId 回溯到根(pi
/// SessionManager 的默认叶语义,旧版 jsonl 只有这一种)。
fn linearize(mut entries: Vec<Value>, active: Option<Vec<usize>>) -> Vec<Value> {
let header_ix = entries
.iter()
.position(|v| v.get("type").and_then(Value::as_str) == Some("session"));
let chain: Vec<usize> = match active {
Some(ix) => ix,
None => {
let by_id: HashMap<&str, usize> = entries
.iter()
.enumerate()
.filter_map(|(i, v)| v.get("id").and_then(Value::as_str).map(|id| (id, i)))
.collect();
let mut chain = Vec::new();
let mut seen = HashSet::new();
let mut cursor = entries
.iter()
.rposition(|v| v.get("id").and_then(Value::as_str).is_some());
while let Some(i) = cursor {
if !seen.insert(i) {
break;
}
chain.push(i);
cursor = entries[i]
.get("parentId")
.and_then(Value::as_str)
.and_then(|p| by_id.get(p).copied());
}
chain.reverse();
chain
}
};
let mut out = Vec::with_capacity(chain.len() + 1);
if let Some(h) = header_ix {
out.push(std::mem::take(&mut entries[h]));
}
for i in chain {
if Some(i) != header_ix {
out.push(std::mem::take(&mut entries[i]));
}
}
out
}
struct ClawParse {
cwd: String,
created_at: i64,
last_ts: i64,
messages: Vec<TranscriptMessage>,
model: Option<String>,
tokens_used: Option<i64>,
/// session_info 的 name(用户/自动命名),标题首选
name: Option<String>,
unknown_lines: u32,
}
fn entry_ts(v: &Value, msg: Option<&Value>) -> i64 {
v.get("timestamp")
.and_then(Value::as_str)
.map(iso_ms)
.filter(|t| *t > 0)
.or_else(|| {
msg.and_then(|m| m.get("timestamp"))
.map(to_epoch_ms)
.filter(|t| *t > 0)
})
.unwrap_or(0)
}
fn render(chain: Vec<Value>, decode_images: bool) -> ClawParse {
let _image_budget = transcript_image_decode_budget(decode_images);
let mut p = ClawParse {
cwd: String::new(),
created_at: 0,
last_ts: 0,
messages: Vec::new(),
model: None,
tokens_used: None,
name: None,
unknown_lines: 0,
};
let mut render = PiRender::new(
PiRenderOptions {
thinking_blocks: true,
meta_carrier: true,
raw_tool_results: true,
},
decode_images,
);
// 非 message 条目(compaction 摘要等)要按位置插在消息流里,故由 render
// 接管 messages,这里只借它推进
for v in &chain {
let Some(typ) = v.get("type").and_then(Value::as_str) else {
p.unknown_lines += 1;
continue;
};
match typ {
"session" => {
if let Some(c) = v.get("cwd").and_then(Value::as_str) {
p.cwd = c.to_string();
}
if let Some(t) = v.get("timestamp").and_then(Value::as_str) {
p.created_at = iso_ms(t);
}
}
"message" => {
let Some(msg) = v.get("message") else {
p.unknown_lines += 1;
continue;
};
let ts = entry_ts(v, Some(msg));
p.last_ts = p.last_ts.max(ts);
if !render.push(msg, ts) {
p.unknown_lines += 1;
}
}
"model_change" => {
if let Some(m) = v.get("modelId").and_then(Value::as_str) {
render.model = Some(m.to_string());
}
}
"compaction" | "branch_summary" => {
let ts = entry_ts(v, None);
p.last_ts = p.last_ts.max(ts);
if let Some(s) = v.get("summary").and_then(Value::as_str) {
if !s.trim().is_empty() {
let mut m = text_msg(Role::System, s, ts);
m.kind = MessageKind::CompactSummary;
render.messages.push(m);
}
}
}
"custom_message" => {
// 扩展注入进上下文的消息:display=true 才是给人看的,折叠为 Meta
if v.get("display").and_then(Value::as_bool) == Some(true) {
let parsed = content_parts(v.get("content").unwrap_or(&Value::Null), false);
if !parsed.text.is_empty() {
let mut m = text_msg(Role::System, &parsed.text, entry_ts(v, None));
m.kind = MessageKind::Meta;
render.messages.push(m);
}
}
}
"session_info" => {
if let Some(n) = v.get("name").and_then(Value::as_str) {
let n = n.trim();
p.name = (!n.is_empty()).then(|| n.to_string());
}
}
other if KNOWN_SKIP.contains(&other) => {}
_ => p.unknown_lines += 1,
}
}
p.messages = render.messages;
p.model = render.model;
p.tokens_used = render.tokens_used;
assign_seq(&mut p.messages);
p
}
impl AgentAdapter for OpenclawAdapter {
fn agent(&self) -> AgentId {
AgentId::Openclaw
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
let mut out = Vec::new();
for dir in self.agent_dirs() {
let db = dir.join("agent").join(DB_NAME);
// 库在却读不出报 Err,scanner 冻结这一家这一轮(不变量 8①)——当成没有会话的话,
// 这一轮会把库里的会话当"磁盘已删"清掉
if db.is_file() {
let rows = self
.rows(&db)
.ok_or_else(|| anyhow!("{} exists but could not be read", db.display()))?;
out.extend(rows.iter().filter(|row| row.event_count > 0).map(|row| {
SessionFileRef {
agent: AgentId::Openclaw,
native_id: row.session_id.clone(),
file_path: virtual_path(&db, &row.session_id),
mtime_ms: row.hint.updated_ms,
size: row.content_len,
}
}));
}
out.extend(legacy_transcripts(&dir.join("sessions")).into_iter().map(
|(stem, path, meta)| SessionFileRef {
agent: AgentId::Openclaw,
native_id: stem,
file_path: path.to_string_lossy().to_string(),
mtime_ms: mtime_ms(&meta),
size: meta.len() as i64,
},
));
}
Ok(out)
}
fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
// 只认 agents/<id>/sessions/<name>.jsonl 这一层;归档/检查点同 list 过滤
let name = path.file_name()?.to_string_lossy().to_string();
if !is_legacy_transcript(&name) {
return None;
}
let sessions = path.parent()?;
if sessions.file_name()?.to_str()? != "sessions" {
return None;
}
if sessions.parent()?.parent()? != self.root {
return None;
}
default_file_ref(AgentId::Openclaw, path)
}
fn manages_parent_links(&self) -> bool {
true
}
/// 库里的窗口与旧版索引一起认:父会话可能在另一个 agent 的库里(跨 agent 派生),也可能
/// 只剩旧版 jsonl。库在却从没读成功过、索引读不出 = 不知道(None),库里的关系原样保留
fn parent_links(&self) -> Option<Vec<(String, String)>> {
// 库里的窗口取这一轮枚举读到的那份(`MtimeCache::latest`:扫描末尾才问到这里,库在扫描
// 期间被写过时按戳重读就是把整个枚举查询再跑一遍)
let mut snapshots = Vec::new();
let mut legacy = Vec::new();
let mut transcripts = Vec::new();
for dir in self.agent_dirs() {
let db = dir.join("agent").join(DB_NAME);
if db.is_file() {
snapshots.push(self.rows_cache_of(&db).latest()?);
}
let sessions = dir.join("sessions");
legacy.push(self.legacy_index(&sessions)?);
transcripts.extend(
legacy_transcripts(&sessions)
.into_iter()
.map(|(stem, ..)| stem),
);
}
// 各 agent 目录收齐了再定:裸文件名优先得在全集上成立,不能看目录先后
let stems = legacy_stems(transcripts);
let all_rows = || snapshots.iter().flat_map(|rows| rows.iter());
// 没有事件的窗口不列(列表同一条),不算"库里那份"——迁进库时没带上事件、旧版 jsonl 还在的
// 会话,列出来的是旧版那份。时间线上照样留着它(下面的 windows)
let legacy_entries = || legacy.iter().flat_map(|index| index.iter());
let in_db: HashSet<&str> = all_rows()
.filter(|row| row.event_count > 0)
.map(|row| row.session_id.as_str())
.collect();
// 会话键 → 库里它的全部窗口(创建时间, 会话 id),空的也算:它在时间线上占着一段,拿掉的话
// 这段里派出的子代理会被挂到更早的那一窗。挑中的是空窗口时,`listed_id` 换成列出来的那份
let mut windows: HashMap<&str, Vec<(i64, &str)>> = HashMap::new();
for row in all_rows() {
windows
.entry(&row.session_key)
.or_default()
.push((row.hint.created_ms, &row.session_id));
}
for list in windows.values_mut() {
list.sort_unstable();
}
let current: HashMap<&str, &str> = legacy_entries()
.map(|(id, (key, _))| (key.as_str(), id.as_str()))
.collect();
// 库里的子会话:那个键在它创建时用着的窗口(不晚于它的最后一个,都晚于它就取最早的),
// 库里没有这个键才退到旧版那一条
let db_parent = |key: &str, at: i64| match windows.get(key) {
Some(list) => list
.iter()
.rev()
.find(|(start, _)| *start <= at)
.or(list.first())
.map(|(_, id)| *id),
None => current.get(key).copied(),
};
// 旧版的子会话:那个键眼下那一条,旧版里没有这个键才退到库里最新的窗口
let legacy_parent = |key: &str| {
current
.get(key)
.copied()
.or_else(|| windows.get(key)?.last().map(|(_, id)| *id))
};
// 子会话(列出来的 id)→ 父会话(列出来的 id)。先放库里每一窗记的,再拿旧版索引里的盖上:
// 库里那份列出来的会话以库为准(旧版只记了父会话的键,下面不碰它);库里那份没事件、列出来
// 的是旧版那份时,旧版索引里有这条会话的关系就用它,没有(子会话键 reset 后索引换成了新的
// 那一条)就留着库里那一行记的
let mut links: HashMap<&str, &str> = HashMap::new();
for row in all_rows() {
let parent = match row.parent.as_ref() {
Some(ParentRef::Session(id)) => Some(id.as_str()),
Some(ParentRef::Key(key)) => db_parent(key, row.hint.created_ms),
None => None,
};
if let Some(parent) = parent {
links.insert(
listed_id(&row.session_id, &in_db, &stems),
listed_id(parent, &in_db, &stems),
);
}
}
let legacy_children: Vec<(&str, ParentRef)> = legacy_entries()
.filter(|(id, _)| !in_db.contains(id.as_str()))
.filter_map(|(id, (_, entry))| Some((id.as_str(), ParentRef::of(Some(entry), None)?)))
.collect();
for (id, parent) in &legacy_children {
let parent = match parent {
ParentRef::Session(parent) => Some(parent.as_str()),
ParentRef::Key(key) => legacy_parent(key),
};
if let Some(parent) = parent {
links.insert(
listed_id(id, &in_db, &stems),
listed_id(parent, &in_db, &stems),
);
}
}
Some(super::link_keys(AgentId::Openclaw, links))
}
/// 关系记在子会话自己的条目里:多 location 下按子会话的胜出副本认边
fn parent_links_in_child(&self) -> bool {
true
}
/// 旧版的父子关系记在 `agents/<x>/sessions/sessions.json` 里,关系里的 id 又按会话目录里
/// 列得出来的转录换算(`listed_id`):两样单独变了(删除也算)都要重取关系
fn is_snapshot_event(&self, path: &Path) -> bool {
path.parent()
.and_then(Path::file_name)
.is_some_and(|name| name == "sessions")
&& path.ancestors().nth(3) == Some(self.root.as_path())
&& path
.file_name()
.and_then(|name| name.to_str())
.is_some_and(|name| name == "sessions.json" || is_legacy_transcript(name))
}
// quick_meta 不覆写:库行给不出标题的可靠来源(名字在 session_info 事件里),
// 走全解析
fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
let (meta, p) = self.parse(r, false)?;
Ok(ParsedSession::derive(meta, &p.messages, p.unknown_lines))
}
fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
let (meta, p) = self.parse(r, true)?;
Ok(ParsedTranscript {
meta,
mainline: p.messages,
sidechains: Vec::new(),
unknown_line_count: p.unknown_lines,
})
}
fn cleanup_paths(&self, meta: &SessionMeta) -> Option<Vec<String>> {
Some(self.session_paths(meta))
}
fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
// 选中状态目录(~/.openclaw)或 agents 目录本身都认;目录尚不存在时按
// 名字判:叫 agents 即是根,否则视作状态目录(远程挂载点 `.openclaw/agents`
// 同步前就落在正确形态)
let is_agents = dir.file_name().and_then(|n| n.to_str()) == Some("agents")
|| (!dir.join("agents").is_dir() && looks_like_agents(&dir));
if is_agents {
return Box::new(Self::with_root(dir));
}
Box::new(Self {
home: Some(dir.clone()),
..Self::with_root(dir.join("agents"))
})
}
fn data_roots(&self) -> Vec<PathBuf> {
vec![self.root.clone()]
}
fn homes(&self) -> Vec<PathBuf> {
self.home.iter().cloned().collect()
}
}
/// 目录里已有 `<x>/sessions` 或 `<x>/agent/openclaw-agent.sqlite` 形态的子目录
/// → 它本身就是 agents 根(用户把 agents 目录改名拷出来的情形)
fn looks_like_agents(dir: &Path) -> bool {
fs::read_dir(dir)
.map(|it| {
it.flatten().any(|e| {
let p = e.path();
p.join("sessions").is_dir() || p.join("agent").join(DB_NAME).is_file()
})
})
.unwrap_or(false)
}