All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
use super::parse_utils::*;
use super::AgentAdapter;
use crate::models::*;
use anyhow::{Context as _, Result};
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
use std::io::{self, BufRead, BufReader};
use std::path::{Path, PathBuf};
use std::sync::Mutex;
/// Craft Agents(craft-ai-agents/craft-agents-oss,Craft Docs 出的开源桌面 app;
/// 2026-09-24 按 v0.13.5 源码落地、真机两条会话核对,issue #44)。它自己不带 agent
/// 引擎:Anthropic 连接跑 Claude Agent SDK(无头 Claude Code,用的是用户真实的
/// `~/.claude`),其余连接(ChatGPT / Codex 订阅、Copilot、Google、OpenAI key…)跑
/// Pi SDK;Craft 在引擎之上另记一份给用户看的会话,Wake 读的就是这一份。
///
/// 布局:`<工作区>/sessions/<id>/session.jsonl`,默认工作区在
/// `~/.craft-agent/workspaces/<slug>/`。工作区可以建在磁盘任意位置(Obsidian 式,
/// 文件夹即工作区),登记在全局 `~/.craft-agent/config.json`——那个文件存着 server
/// token 与远程工作区 token,**不读**;别处的工作区由用户在 Session locations 里加
/// (根可以选工作区集合、单个工作区或 `.craft-agent` 本身)。
///
/// 首行 SessionHeader(name 是 AI 起的或用户改的标题,preview 是首条提问,
/// workingDirectory 是用户设的项目目录,sdkSessionId 是引擎那份转录的 id…),其余每行
/// 一条 StoredMessage:`type` ∈ user / assistant / tool / plan / info / error /
/// warning / auth-request;工具调用一行自带 toolInput 与 toolResult;不落 thinking。
/// 会话目录里的路径在盘上写成 `{{SESSION_PATH}}` 占位,读时展开。整文件重写
/// (写 .tmp → **先 unlink 正本** → rename)。会话 id(`YYMMDD-形容词-名词`)只在工作区
/// 内唯一,native id 因此带工作区命名空间:`<工作区 config.json 的 id>/<会话目录>`
/// (见 workspace_ns)。
///
/// 引擎的原料不读:Pi 的写在会话目录里的 `.pi-sessions/`(Wake 的 Pi adapter 不扫那里);
/// Claude 的那份落在 `~/.claude/projects/<sdkCwd>/<sdkSessionId>.jsonl`、被 Claude
/// adapter 收成一条 Claude Code 会话——由 `claimed_sessions` 认领掉,同一段对话只列一次
pub struct CraftAdapter {
/// 工作区集合(默认 `~/.craft-agent/workspaces`)或单个工作区
root: PathBuf,
heads: HeadCache,
workspaces: WorkspaceIds,
/// `~/.craft-agent`;直接选中工作区集合或单个工作区的自定义根没有
home: Option<PathBuf>,
}
impl CraftAdapter {
pub fn new() -> Self {
let home = super::home_dir().unwrap_or_default().join(".craft-agent");
Self {
home: Some(home.clone()),
..Self::at(home.join("workspaces"))
}
}
fn at(root: PathBuf) -> Self {
Self {
root,
heads: HeadCache::default(),
workspaces: WorkspaceIds::default(),
home: None,
}
}
/// 根下每个会话目录的 session.jsonl 路径(含隐藏会话——列表过滤在 file_ref,认领要看
/// 全部;文件在不在交给调用方那一次 stat),顺带把首行缓存收成只剩这些路径。根是工作区
/// 集合时会话在 `<根>/<工作区>/sessions/*`,是单个工作区时在 `<根>/sessions/*`,两种
/// 形态都走一遍:错位的那一层没有 sessions/,NotFound 自然跳过。第二项为 false = 有目录
/// 在却读不出来:枚举照用读到的那些,父子关系与认领的快照则不能当完整的交出去
fn session_files(&self) -> (Vec<PathBuf>, bool) {
let mut complete = true;
let mut subdirs = |dir: &Path| -> Vec<PathBuf> {
match fs::read_dir(dir) {
Ok(entries) => entries
.flatten()
.filter(|e| e.file_type().is_ok_and(|t| t.is_dir()))
.map(|e| e.path())
.collect(),
Err(e) => {
complete &= matches!(
e.kind(),
io::ErrorKind::NotFound | io::ErrorKind::NotADirectory
);
Vec::new()
}
}
};
let mut workspaces = vec![self.root.clone()];
workspaces.extend(subdirs(&self.root));
let mut files: Vec<PathBuf> = workspaces
.iter()
.flat_map(|workspace| subdirs(&workspace.join("sessions")))
.map(|session| session.join(SESSION_FILE))
.collect();
files.sort();
self.heads.retain_only(&files);
(files, complete)
}
/// 全部会话的首行摘要(父子关系与认领用)。**`None` = 这一刻有东西读不出来、又没有
/// 上次读到的可顶**:拿缺一块的快照去对账,那块的认领会被撤掉、父子关系会被当成解除。
/// 首行本身写坏了(craft 自己也列不出这种会话)才算没有
fn all_heads(&self) -> Option<Vec<(PathBuf, Head)>> {
let (files, complete) = self.session_files();
if !complete {
return None;
}
let mut heads = Vec::with_capacity(files.len());
for path in files {
let head = fs::metadata(&path)
.and_then(|meta| self.heads.get(&path, mtime_ms(&meta), meta.len() as i64));
match head {
Ok(Some(head)) => heads.push((path, head)),
Ok(None) => {}
// 读不出来(含 craft 原子写"先删正本、再把 .tmp 改名过来"的那个空档)沿用上次
// 读到的;没读过的,文件不在就当它还没有,别的错误才是真不知道
Err(e) => match self.heads.last(&path) {
Some(head) => heads.push((path, head)),
None if e.kind() == io::ErrorKind::NotFound => {}
None => return None,
},
}
}
Some(heads)
}
/// 工作区在会话 key 里的命名空间:它自己 config.json 里的 `id`(craft 建工作区时随机
/// 生成,改名、挪位置都不变;整个工作区备份一份,备份里的会话仍算同一条)。不用目录名:
/// 会话 id 只在工作区内唯一,两个同名文件夹的工作区同一天生成同一个 id 就撞 key,被当成
/// 副本吞掉一条。没有 config.json(craft 自己都不认它是工作区)或里面没有 id,退回目录名;
/// config.json 在却读不出来,沿用上次读到的,没读过给 None——别拿目录名顶,key 一换就是
/// 另一条会话(craft 写 config.json 是 tmp + rename,正常不会读到半截)
fn workspace_ns(&self, workspace_dir: &Path) -> Option<String> {
let dir_name = || Some(workspace_dir.file_name()?.to_string_lossy().to_string());
let config = workspace_dir.join("config.json");
let mut cache = self.workspaces.0.lock().unwrap();
let last = cache.get(workspace_dir).cloned();
let stamp = match fs::metadata(&config) {
Ok(meta) => (mtime_ms(&meta), meta.len() as i64),
Err(e) if e.kind() == io::ErrorKind::NotFound => return dir_name(),
Err(_) => return last.map(|(_, ns)| ns),
};
if let Some((_, ns)) = last.as_ref().filter(|(cached, _)| *cached == stamp) {
return Some(ns.clone());
}
let Some(config) = fs::read_to_string(&config)
.ok()
.and_then(|raw| serde_json::from_str::<Value>(&raw).ok())
else {
return last.map(|(_, ns)| ns);
};
let ns = str_at(&config, "id")
.map(str::to_string)
.or_else(dir_name)?;
cache.insert(workspace_dir.to_path_buf(), (stamp, ns.clone()));
Some(ns)
}
/// 会话文件 → native id;不是 `<工作区>/sessions/<会话>/session.jsonl` 形状、或工作区 id
/// 这一刻读不出来,给 None
fn native_id_of(&self, session_file: &Path) -> Option<String> {
let session_dir = session_file.parent()?;
let sessions_dir = session_dir.parent()?;
if sessions_dir.file_name()? != "sessions" {
return None;
}
let ns = self.workspace_ns(sessions_dir.parent()?)?;
Some(native_id(&ns, &session_dir.file_name()?.to_string_lossy()))
}
}
/// 入库前的自定义根归一化(`adapters::normalize_custom_root` 按 agent 分派到这里):
/// 目录选择器里选中的是某个工作区的 `sessions/` 就上提到工作区——那一层下面的
/// `<会话>/session.jsonl` 两种枚举形态都够不着。自己底下还有 `sessions/` 的,说明
/// 它本身就是个叫 sessions 的工作区,不动
pub fn normalize_custom_root(dir: PathBuf) -> PathBuf {
let is_sessions_dir =
dir.file_name().is_some_and(|n| n == "sessions") && !dir.join("sessions").is_dir();
match dir.parent() {
Some(workspace) if is_sessions_dir => workspace.to_path_buf(),
_ => dir,
}
}
const SESSION_FILE: &str = "session.jsonl";
/// 盘上写成占位的会话目录(craft `makeSessionPathPortable`),读时换回真实路径
const SESSION_PATH_TOKEN: &str = "{{SESSION_PATH}}";
/// Claude 后端的回合锚点边车:Craft 的助手消息 id → 它所在的引擎会话
const CLAUDE_ANCHORS: &str = "meta/claude-turn-anchors.json";
/// native id = `<工作区命名空间>/<会话目录>`(见 workspace_ns)。`:` 是会话 key 的分段符、
/// `/` 分开两段,出现在各段里就换掉。会话自己与 parent_links 里的父会话都经这里拼——两端
/// 差一个字符父子关系就静默对不上
fn native_id(ns: &str, session: &str) -> String {
format!(
"{}/{}",
ns.replace([':', '/'], "_"),
session.replace([':', '/'], "_")
)
}
fn workspace_dir_of(session_file: &Path) -> Option<&Path> {
session_file.parent()?.parent()?.parent()
}
fn session_key_of(native: &str) -> String {
session_key(AgentId::CraftAgents, "", native)
}
/// 首行里枚举、父子关系与认领要用的几项(缓存单位)
#[derive(Clone)]
struct Head {
/// 不进列表:mini 编辑会话(hidden)与看板上还没领养的任务草稿(taskDraft)
hidden: bool,
/// 同工作区的父会话目录名:spawn_session 派出的子任务(parentSessionId),
/// 或分支的来源(branchFromSessionPath 的末段)
parent: Option<String>,
/// 这条会话在 Claude 引擎那边的转录 id(Pi 后端的会话没有)
claude_ids: Vec<String>,
}
fn str_at<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
v.get(key)
.and_then(Value::as_str)
.map(str::trim)
.filter(|s| !s.is_empty())
}
fn true_at(v: &Value, key: &str) -> bool {
v.get(key).and_then(Value::as_bool) == Some(true)
}
/// 首行 header。消息行都带 `type`,header 没有——拿它区分。`Ok(None)` = 首行不是 header
/// (写坏了,craft 自己也列不出这种会话);打不开、读出错是 `Err`——那是"这一刻不知道"
fn read_header(path: &Path) -> io::Result<Option<Value>> {
let mut line = String::new();
BufReader::with_capacity(16 << 10, fs::File::open(path)?).read_line(&mut line)?;
Ok(parse_header(&line))
}
fn parse_header(line: &str) -> Option<Value> {
let v: Value = serde_json::from_str(line.trim_end()).ok()?;
(v.is_object() && v.get("type").is_none()).then_some(v)
}
fn is_pi_model(header: &Value) -> bool {
str_at(header, "model").is_some_and(|m| m.starts_with("pi/"))
}
fn head_of(path: &Path, header: &Value) -> io::Result<Head> {
let parent = str_at(header, "parentSessionId")
.map(str::to_string)
.or_else(|| {
str_at(header, "branchFromSessionPath").and_then(|p| {
// 绝对路径(craft 不把它转成 ~ 形态);两种分隔符都认
p.rsplit(['/', '\\'])
.find(|s| !s.is_empty())
.map(str::to_string)
})
});
let mut claude_ids = Vec::new();
// Pi 后端的 sdkSessionId 是 Pi 自己的会话 id,认领它只会往表里塞永远对不上的 key
if !is_pi_model(header) {
claude_ids.extend(str_at(header, "sdkSessionId").map(str::to_string));
// 回合锚点记着每条助手消息实际落在哪份引擎转录里:续跑或恢复换过 SDK 会话时,
// 旧的那份照样装着这条会话的对话。没有边车、边车写坏了就只认 header 里当前那份;
// 读出错往上报(不知道)。与 header 重复的 id 在 claimed_sessions 里去重
let anchors = match path
.parent()
.map(|dir| fs::read_to_string(dir.join(CLAUDE_ANCHORS)))
{
Some(Ok(raw)) => serde_json::from_str::<Value>(&raw).ok(),
Some(Err(e)) if e.kind() != io::ErrorKind::NotFound => return Err(e),
_ => None,
};
claude_ids.extend(
anchors
.iter()
.filter_map(|a| a.get("anchors")?.as_object())
.flat_map(|m| m.values())
.filter_map(|record| str_at(record, "sdkSessionId"))
.map(str::to_string),
);
}
Ok(Head {
hidden: true_at(header, "hidden") || true_at(header, "taskDraft"),
parent,
claude_ids,
})
}
/// 首行摘要按 (session.jsonl 的 mtime、size, 锚点边车的 mtime) 缓存:每轮扫描、每批
/// watcher 事件都要把全部会话的首行过一遍(列表过滤、父子关系、认领),文件没变
/// 就不再打开
#[derive(Default)]
struct HeadCache(Mutex<HashMap<PathBuf, ((i64, i64, i64), Head)>>);
impl HeadCache {
/// `mtime` / `size` 是调用方已经 stat 过的 session.jsonl。`Ok(None)` = 首行不是 header
fn get(&self, path: &Path, mtime: i64, size: i64) -> io::Result<Option<Head>> {
let anchors_mtime = path
.parent()
.and_then(|dir| fs::metadata(dir.join(CLAUDE_ANCHORS)).ok())
.map(|m| mtime_ms(&m))
.unwrap_or(0);
let stamp = (mtime, size, anchors_mtime);
if let Some((cached, head)) = self.0.lock().unwrap().get(path) {
if *cached == stamp {
return Ok(Some(head.clone()));
}
}
let Some(header) = read_header(path)? else {
return Ok(None);
};
let head = head_of(path, &header)?;
self.0
.lock()
.unwrap()
.insert(path.to_path_buf(), (stamp, head.clone()));
Ok(Some(head))
}
/// 上次读到的(不管文件后来变没变):这一刻读不出来时顶上
fn last(&self, path: &Path) -> Option<Head> {
self.0
.lock()
.unwrap()
.get(path)
.map(|(_, head)| head.clone())
}
/// 缓存只留这次枚举到的会话文件(删掉的会话不再占着)
fn retain_only(&self, files: &[PathBuf]) {
let live: std::collections::HashSet<&Path> = files.iter().map(PathBuf::as_path).collect();
self.0
.lock()
.unwrap()
.retain(|p, _| live.contains(p.as_path()));
}
}
/// 工作区命名空间(workspace_ns)按工作区目录缓存,戳是它 config.json 的 (mtime, size):
/// 每个会话的 key 都要问一次,工作区只有几个
#[derive(Default)]
struct WorkspaceIds(Mutex<HashMap<PathBuf, ((i64, i64), String)>>);
/// JSON 值里所有字符串中的 `{{SESSION_PATH}}` 换回会话目录。解析之后再换:
/// Windows 路径里的反斜杠直接塞进 JSON 文本会破坏转义
fn expand_session_path(v: &mut Value, dir: &str) {
match v {
Value::String(s) if s.contains(SESSION_PATH_TOKEN) => {
*s = s.replace(SESSION_PATH_TOKEN, dir);
}
Value::Array(items) => items.iter_mut().for_each(|i| expand_session_path(i, dir)),
Value::Object(map) => map.values_mut().for_each(|i| expand_session_path(i, dir)),
_ => {}
}
}
struct CraftParse {
header: Value,
messages: Vec<TranscriptMessage>,
last_ts: i64,
unknown_lines: u32,
}
/// 用户消息正文:原话 + 附件名(与 craft 递给模型的 `[Attached file: …]` 同一写法)
fn user_text(row: &Value) -> String {
let mut text = str_at(row, "content").unwrap_or_default().to_string();
for name in row
.get("attachments")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|a| str_at(a, "name"))
{
if !text.is_empty() {
text.push('\n');
}
text.push_str(&format!("[Attached file: {name}]"));
}
text
}
fn tool_view(row: &Value) -> ToolCallView {
let id = str_at(row, "toolUseId")
.or_else(|| str_at(row, "id"))
.unwrap_or_default()
.to_string();
let input = row.get("toolInput").cloned().unwrap_or(Value::Null);
let output = str_at(row, "toolResult").map(str::to_string);
// craft 对没显式标错、但以 [ERROR] / Error: 开头的结果也记成 error 状态
let is_error = true_at(row, "isError") || str_at(row, "toolStatus") == Some("error");
tool_call_view(
id,
str_at(row, "toolName").unwrap_or_default(),
&input,
output,
is_error,
)
}
fn parse_file(path: &Path) -> Result<CraftParse> {
let raw = fs::read_to_string(path)
.with_context(|| format!("read craft session {}", path.display()))?;
let dir = path
.parent()
.map(|d| d.to_string_lossy().to_string())
.unwrap_or_default();
let mut lines = raw.lines();
let mut header = lines
.next()
.and_then(parse_header)
.context("craft session.jsonl has no session header")?;
expand_session_path(&mut header, &dir);
let branch_point = str_at(&header, "branchFromMessageId").map(str::to_string);
let mut messages: Vec<TranscriptMessage> = Vec::new();
// 分支会话自己的消息从这个下标开始;之前的是从父会话复制来的(折叠用)
let mut own_from: Option<usize> = None;
let mut last_ts = 0i64;
let mut unknown_lines = 0u32;
for line in lines {
if line.trim().is_empty() {
continue;
}
// 崩溃时写断的行 craft 自己也是跳过(parseMessagesResilient)
let Ok(mut row) = serde_json::from_str::<Value>(line) else {
unknown_lines += 1;
continue;
};
expand_session_path(&mut row, &dir);
let ts = row.get("timestamp").map(to_epoch_ms).unwrap_or(0);
last_ts = last_ts.max(ts);
// 子代理(Task 工具)内部的话与工具调用挂着 parentToolUseId:不进主线,
// 子代理的结论在 Task 工具自己的结果里
let nested = str_at(&row, "parentToolUseId").is_some();
match row.get("type").and_then(Value::as_str).unwrap_or_default() {
"user" => {
let text = user_text(&row);
if !text.trim().is_empty() {
let mut m = text_msg(Role::User, &text, ts);
// 系统生成、只给模型看的推动消息(后台任务完成的提醒一类)
if true_at(&row, "hidden") {
m.kind = MessageKind::Meta;
}
messages.push(m);
}
}
"assistant" if !nested => {
if let Some(text) = str_at(&row, "content") {
messages.push(text_msg(Role::Assistant, text, ts));
}
}
// 计划(Explore 模式下 SubmitPlan 交上来的整份 Markdown)是助手的产出
"plan" => {
if let Some(text) = str_at(&row, "content") {
messages.push(text_msg(Role::Assistant, text, ts));
}
}
"tool" if !nested => {
// 挂到本段最近的助手消息上(craft 先落助手的过渡话、再落它发起的工具);
// 前面没有可挂的(工具先行,或上一条是分叉点之前复制来的)就起一条空的承载
let host = messages.len().checked_sub(1).filter(|&last| {
messages[last].role == Role::Assistant
&& messages[last].kind == MessageKind::Text
&& own_from.is_none_or(|from| last >= from)
});
let ix = match host {
Some(ix) => ix,
None => {
messages.push(text_msg(Role::Assistant, "", ts));
messages.len() - 1
}
};
messages[ix].tool_calls.push(tool_view(&row));
}
"assistant" | "tool" => {}
// 压缩完成、授权请求、报错与警告:会话里的系统事件
"info" | "error" | "warning" | "auth-request" => {
let text = str_at(&row, "content").or_else(|| str_at(&row, "errorTitle"));
if let Some(text) = text {
messages.push(meta_msg(text, ts));
}
}
// 进度状态 craft 本就不落盘(persist 前滤掉),见到也不算漂移
"status" => {}
_ => unknown_lines += 1,
}
if own_from.is_none()
&& branch_point.is_some()
&& str_at(&row, "id") == branch_point.as_deref()
{
own_from = Some(messages.len());
}
}
// 分支 = 父会话到分叉点为止的消息原样复制进来 + 自己的续写(craft createSession
// 的 branch copy),复制段折成一条标记
if let Some(cut) = own_from {
collapse_inherited(&mut messages, cut, "session");
}
assign_seq(&mut messages);
Ok(CraftParse {
header,
messages,
last_ts,
unknown_lines,
})
}
fn epoch_at(v: &Value, key: &str) -> i64 {
v.get(key).map(to_epoch_ms).unwrap_or(0)
}
fn build_meta(r: &SessionFileRef, p: &CraftParse) -> SessionMeta {
let path = Path::new(&r.file_path);
let h = &p.header;
// 标题:craft 的 name(AI 起的或用户改的)> 首条真实提问 > craft 记的预览。分支的
// 预览是父会话的首条提问,不拿它当自己的标题
let title = str_at(h, "name")
.map(clean_title_candidate)
.filter(|t| !t.is_empty())
.or_else(|| title_from_messages(&p.messages))
.or_else(|| {
str_at(h, "preview")
.filter(|_| str_at(h, "branchFromMessageId").is_none())
.map(clean_title_candidate)
.filter(|t| !t.is_empty())
})
.unwrap_or_else(|| UNTITLED.to_string());
// 项目:用户给会话设了工作目录就是它;没设(craft 的默认)就归到工作区本身——取首行记的
// 工作区路径:远程镜像里文件所在的是本机缓存目录,拿它当项目,按远端路径就筛不到。首行
// 的路径是 craft 的 ~ 形态(toPortablePath,workingDirectory 同样),按本机家目录展开——
// 远程镜像的 ~ 本该是远端家目录,那边探测不到,与其他远程路径假设同一局限;没记才退回文件位置
let project_path = str_at(h, "workingDirectory")
.or_else(|| str_at(h, "workspaceRootPath"))
.map(super::expand_tilde)
.or_else(|| workspace_dir_of(path).map(|w| w.to_string_lossy().to_string()))
.unwrap_or_default();
let created = epoch_at(h, "createdAt");
// lastUsedAt 连"点开看一眼"都会刷新,不是活动时间。lastMessageAt 实测只在用户发言时
// 前移(助手几秒后的回复不算),与消息自己的时间戳取大者
let updated = [epoch_at(h, "lastMessageAt").max(p.last_ts), created]
.into_iter()
.find(|t| *t > 0)
.unwrap_or(r.mtime_ms);
let usage = h.get("tokenUsage").unwrap_or(&Value::Null);
let count = |key: &str| usage.get(key).and_then(Value::as_f64).unwrap_or(0.0) as i64;
let tokens = match count("totalTokens") {
0 => count("inputTokens") + count("outputTokens"),
total => total,
};
SessionMeta {
key: session_key_of(&r.native_id),
id: r.native_id.clone(),
host: String::new(),
agent: AgentId::CraftAgents,
title,
project_name: project_name_of(&project_path),
project_path,
file_path: r.file_path.clone(),
created_at: if created > 0 { created } else { r.mtime_ms },
updated_at: updated,
message_count: p
.messages
.iter()
.filter(|m| m.kind == MessageKind::Text)
.count() as i64,
size_bytes: r.size,
git_branch: None,
// Pi 后端的模型写成 `pi/<id>`
model: str_at(h, "model").map(|m| m.strip_prefix("pi/").unwrap_or(m).to_string()),
tokens_used: (tokens > 0).then_some(tokens),
archived: true_at(h, "isArchived"),
// 自动化(定时 / 标签变化触发的 prompt)建出来的会话
source: h
.get("triggeredBy")
.is_some_and(|t| t.is_object())
.then(|| "automation".to_string()),
spawned: str_at(h, "taskRunId").is_some() || str_at(h, "taskNodeId").is_some(),
favorite: false,
pinned: false,
}
}
impl AgentAdapter for CraftAdapter {
fn agent(&self) -> AgentId {
AgentId::CraftAgents
}
fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
let (files, _) = self.session_files();
Ok(files.iter().filter_map(|f| self.file_ref(f)).collect())
}
fn file_ref(&self, path: &Path) -> Option<SessionFileRef> {
// 只认会话主文件:.tmp(原子写的中间态)、.pi-sessions/ 里 Pi 引擎的原料都不是
if path.file_name()? != SESSION_FILE {
return None;
}
let mut r = default_file_ref(AgentId::CraftAgents, path)?;
r.native_id = self.native_id_of(path)?;
let head = match self.heads.get(path, r.mtime_ms, r.size) {
// None = 首行写坏了,craft 自己也列不出
Ok(head) => head?,
// 这一刻读不出来:按上次读到的算,没读过就先不列
Err(_) => self.heads.last(path)?,
};
(!head.hidden).then_some(r)
}
fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
let parsed = parse_file(Path::new(&r.file_path))?;
Ok(ParsedSession::derive(
build_meta(r, &parsed),
&parsed.messages,
parsed.unknown_lines,
))
}
fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
let parsed = parse_file(Path::new(&r.file_path))?;
Ok(ParsedTranscript {
meta: build_meta(r, &parsed),
mainline: parsed.messages,
sidechains: Vec::new(),
unknown_line_count: parsed.unknown_lines,
})
}
fn session_paths(&self, meta: &SessionMeta) -> Vec<String> {
// 一目录一会话:附件、计划、下载、引擎原料都在会话目录里,整个 trash
// (craft 自己删会话也是删整个目录)
match Path::new(&meta.file_path).parent() {
Some(dir) => vec![dir.to_string_lossy().to_string()],
None => vec![meta.file_path.clone()],
}
}
fn cleanup_paths(&self, meta: &SessionMeta) -> Option<Vec<String>> {
Some(self.session_paths(meta))
}
fn manages_parent_links(&self) -> bool {
true
}
/// 子任务(spawn_session / 看板)与分支都挂到同工作区的父会话下。任一会话的首行或
/// 工作区 id 这一刻读不出来,整份交回 None(不知道),别让缺的那几条被当成关系解除
fn parent_links(&self) -> Option<Vec<(String, String)>> {
let mut links = Vec::new();
for (path, head) in self.all_heads()? {
let Some(parent) = head.parent.filter(|_| !head.hidden) else {
continue;
};
let ns = self.workspace_ns(workspace_dir_of(&path)?)?;
let child = native_id(&ns, &path.parent()?.file_name()?.to_string_lossy());
let parent = native_id(&ns, &parent);
if parent != child {
links.push((session_key_of(&child), session_key_of(&parent)));
}
}
Some(links)
}
/// 关系写在子会话自己的首行里(不是 Grok 那种长在父会话 location 里的边车):
/// 多 location 下 scanner 按子会话的胜出文件认边
fn parent_links_in_child(&self) -> bool {
true
}
/// 首行(隐藏会话的也算——它们 file_ref 不收)与回合锚点边车决定父子关系与认领
fn is_snapshot_event(&self, path: &Path) -> bool {
path.file_name().is_some_and(|n| n == SESSION_FILE) || path.ends_with(CLAUDE_ANCHORS)
}
fn manages_claims(&self) -> bool {
true
}
/// Claude 后端的会话在 `~/.claude/projects` 里各有一份引擎转录。隐藏的 mini 编辑
/// 会话也认领:它们不进列表,引擎那份同样不该以 Claude Code 会话冒出来。有首行读不
/// 出来就交回 None,scanner 保留库里的认领
fn claimed_sessions(&self) -> Option<Vec<(AgentId, String)>> {
let mut ids: Vec<String> = self
.all_heads()?
.into_iter()
.flat_map(|(_, head)| head.claude_ids)
.collect();
ids.sort();
ids.dedup();
Some(
ids.into_iter()
.map(|id| (AgentId::ClaudeCode, id))
.collect(),
)
}
fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
// 选中的是 `.craft-agent` 本身就下到它的 workspaces/;工作区集合与单个工作区
// 两种形态 session_files 都认
if dir.join("workspaces").is_dir() {
return Box::new(Self {
home: Some(dir.clone()),
..Self::at(dir.join("workspaces"))
});
}
Box::new(Self::at(dir))
}
fn data_roots(&self) -> Vec<PathBuf> {
vec![self.root.clone()]
}
fn homes(&self) -> Vec<PathBuf> {
self.home.iter().cloned().collect()
}
}