All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.
Rust
//! wake-mcp 的端到端契约:合成 fixtures 建临时库 → 以真实 bin 起子进程 → 走
//! stdio JSON-RPC。卡住:工具清单稳定;search 命中的 seq 等于 parse_transcript
//! 的序号(seq 契约延伸到 MCP);get_session 分页的 next_seq 逐页衔接、覆盖全部
//! 非 Meta 消息;全程只读(库文件字节不变);坏 key 是 isError 而非崩溃;未知
//! 方法 -32601;库不存在时进程以清晰错误退出。
//!
//! WAKE_HOME 是进程级环境且子进程继承它,整个文件只有一个用例。
use std::io::{BufRead, BufReader, Write};
use std::path::Path;
use std::process::{Child, ChildStdin, ChildStdout, Command, Stdio};
use std::sync::Arc;
use serde_json::{json, Value};
use wake_core::adapters::{adapter_for, create_adapter_roster_for};
use wake_core::db::Store;
use wake_core::mcp::{self, tools, Usage, ON_REQUEST_ENV};
use wake_core::models::*;
use wake_core::scanner::{run_scan, NullEvents};
mod common;
const CLAUDE_KEY: &str = "claude-code:11111111-aaaa-bbbb-cccc-000000000001";
const CLAUDE_PROJECT: &str = "/Users/tester/Github/wakefx";
struct Client {
child: Child,
stdin: Option<ChildStdin>,
stdout: BufReader<ChildStdout>,
next_id: i64,
}
impl Client {
fn spawn(db: &Path) -> Client {
Self::spawn_with(db, |_| {})
}
/// `with` 加参数、设环境变量。跑测试的环境里设了 WAKE_ON_REQUEST 也先清掉,默认那套说明
/// 才是确定的
fn spawn_with(db: &Path, with: impl FnOnce(&mut Command)) -> Client {
let mut cmd = Command::new(env!("CARGO_BIN_EXE_wake-mcp"));
cmd.arg("--db")
.arg(db)
.env_remove(ON_REQUEST_ENV)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::null());
with(&mut cmd);
let mut child = cmd.spawn().expect("spawn wake-mcp");
let stdin = child.stdin.take().unwrap();
let stdout = BufReader::new(child.stdout.take().unwrap());
Client {
child,
stdin: Some(stdin),
stdout,
next_id: 0,
}
}
fn send_raw(&mut self, line: &str) {
let stdin = self.stdin.as_mut().unwrap();
stdin.write_all(line.as_bytes()).unwrap();
stdin.write_all(b"\n").unwrap();
stdin.flush().unwrap();
}
fn read_reply(&mut self) -> Value {
let mut line = String::new();
let n = self.stdout.read_line(&mut line).expect("read reply");
assert!(n > 0, "wake-mcp closed stdout unexpectedly");
serde_json::from_str(&line).unwrap_or_else(|e| panic!("reply is not JSON: {e}: {line}"))
}
fn request(&mut self, method: &str, params: Value) -> Value {
self.next_id += 1;
let id = self.next_id;
self.send_raw(
&json!({ "jsonrpc": "2.0", "id": id, "method": method, "params": params }).to_string(),
);
let reply = self.read_reply();
assert_eq!(reply["jsonrpc"], "2.0");
assert_eq!(reply["id"], id, "reply id mismatch: {reply}");
reply
}
fn initialize(&mut self) -> Value {
self.request(
"initialize",
json!({
"protocolVersion": "2025-06-18",
"capabilities": {},
"clientInfo": { "name": "wake-test", "version": "0" }
}),
)
}
fn notify(&mut self, method: &str) {
self.send_raw(&json!({ "jsonrpc": "2.0", "method": method }).to_string());
}
/// tools/call → (text, isError);协议错误直接 panic
fn call(&mut self, tool: &str, args: Value) -> (String, bool) {
let reply = self.request("tools/call", json!({ "name": tool, "arguments": args }));
assert!(
reply.get("error").is_none(),
"{tool} returned a protocol error: {}",
reply["error"]
);
let result = &reply["result"];
let text = result["content"][0]["text"]
.as_str()
.unwrap_or_else(|| panic!("{tool} result has no text content: {result}"))
.to_string();
(text, result["isError"].as_bool().unwrap_or(false))
}
fn finish(mut self) {
drop(self.stdin.take());
let status = self.child.wait().expect("wait wake-mcp");
assert!(status.success(), "wake-mcp exited with {status}");
}
}
/// `### [seq N]` 标题里的 seq,按出现顺序
fn seqs_in(text: &str) -> Vec<i64> {
text.lines()
.filter_map(|l| l.strip_prefix("### [seq "))
.filter_map(|rest| rest.split(']').next()?.parse().ok())
.collect()
}
fn next_seq_hint(text: &str) -> Option<i64> {
text.lines()
.find_map(|l| l.split("from_seq=").nth(1))
.and_then(|rest| rest.trim_end_matches('.').trim().parse().ok())
}
#[test]
fn stdio_contract_end_to_end() {
let tmp = tempfile::Builder::new()
.prefix("wake-mcp-e2e-")
.tempdir()
.unwrap();
let home = tmp.path().join("home");
common::stage_dir_fixtures(&home);
common::stage_sidecars(&home);
// 子进程继承这些:它的 roster 也要指向 fixture home,别读到开发机的真实数据
common::isolate_home(&home);
// 1. 建库 + 全量扫描,并从本进程算出 seq 契约的参照
let db = tmp.path().join("wake.db");
let expected_seqs: Vec<i64>;
let qr_seq: i64;
let total_sessions: i64;
{
let store = Arc::new(Store::open(&db).unwrap());
let roster = create_adapter_roster_for(&store);
run_scan(&roster.active, &store, &NullEvents, true).expect("scan ok");
let (_, total) = store
.list_sessions(&SessionFilter {
limit: 1,
..Default::default()
})
.unwrap();
total_sessions = total;
let meta = store
.get_session(CLAUDE_KEY)
.unwrap()
.expect("claude fixture indexed");
assert_eq!(meta.project_path, CLAUDE_PROJECT);
let adapter = adapter_for(&roster.active, meta.agent, &meta.file_path).unwrap();
let t = adapter
.parse_transcript(&SessionFileRef::from_meta(&meta))
.unwrap();
expected_seqs = t
.mainline
.iter()
.filter(|m| m.kind != MessageKind::Meta)
.map(|m| m.seq)
.collect();
qr_seq = t
.mainline
.iter()
.find(|m| m.text.contains("二维码"))
.map(|m| m.seq)
.expect("fixture has the 二维码 prompt");
// Store 在这里关闭:最后一个连接落盘 checkpoint 之后再拍库文件快照
}
assert!(
total_sessions > 10,
"fixture home should index many sessions"
);
let before = std::fs::read(&db).unwrap();
// 2. 握手与协议面
let mut c = Client::spawn(&db);
let init = c.initialize();
assert_eq!(init["result"]["protocolVersion"], "2025-06-18");
assert_eq!(init["result"]["serverInfo"]["name"], "wake");
assert!(init["result"]["capabilities"]["tools"].is_object());
assert!(init["result"]["instructions"]
.as_str()
.unwrap()
.contains("wake_search"));
c.notify("notifications/initialized");
assert_eq!(c.request("ping", json!({}))["result"], json!({}));
let tools = c.request("tools/list", json!({}));
let names: Vec<&str> = tools["result"]["tools"]
.as_array()
.unwrap()
.iter()
.map(|t| t["name"].as_str().unwrap())
.collect();
assert_eq!(
names,
[
"wake_search",
"wake_list_sessions",
"wake_get_session",
"wake_list_projects",
"wake_list_memories"
]
);
let unknown = c.request("resources/list", json!({}));
assert_eq!(unknown["error"]["code"], -32601);
let bad_tool = c.request(
"tools/call",
json!({ "name": "wake_delete_everything", "arguments": {} }),
);
assert_eq!(bad_tool["error"]["code"], -32602);
let bad_since = c.request(
"tools/call",
json!({ "name": "wake_list_sessions", "arguments": { "since": "yesterday" } }),
);
assert_eq!(bad_since["error"]["code"], -32602, "参数形状错是协议错误");
// 非 ASCII 收尾的 since 曾让 split_at 在字符中间 panic、整个 server 退出
let cjk_since = c.request(
"tools/call",
json!({ "name": "wake_list_sessions", "arguments": { "since": "7天" } }),
);
assert_eq!(cjk_since["error"]["code"], -32602, "{cjk_since}");
c.send_raw("{not json");
let parse_err = c.read_reply();
assert_eq!(parse_err["error"]["code"], -32700);
assert!(parse_err["id"].is_null());
// 3. search 命中的 seq 与 parse_transcript 的序号一致(seq 契约)。fixture
// home 里十几家都有 "二维码" 提示词,按 agent 收窄让断言不依赖 bm25 排位
let (everywhere, is_err) = c.call("wake_search", json!({ "query": "二维码", "limit": 30 }));
assert!(!is_err, "{everywhere}");
assert!(
everywhere.contains("sessions match `二维码`"),
"{everywhere}"
);
let (text, is_err) = c.call(
"wake_search",
json!({ "query": "二维码", "agents": ["claude"], "project": CLAUDE_PROJECT }),
);
assert!(!is_err, "{text}");
assert!(text.contains(CLAUDE_KEY), "{text}");
let expected_ref = format!("ref: wake://session/{CLAUDE_KEY}#{qr_seq}");
assert!(
text.contains(&expected_ref),
"search hit must cite seq {qr_seq}:\n{text}"
);
assert!(text.contains("Index covers activity up to"));
// 4. get_session:引用形态起点、分页衔接、覆盖全部非 Meta 消息
let (page, is_err) = c.call(
"wake_get_session",
json!({ "key": format!("wake://session/{CLAUDE_KEY}#{qr_seq}"), "max_messages": 1 }),
);
assert!(!is_err, "{page}");
assert_eq!(seqs_in(&page), vec![qr_seq]);
assert!(page.contains("二维码"));
assert!(page.contains("key: `claude-code:"));
let mut visited = Vec::new();
let mut from = 0;
for _ in 0..50 {
let (page, is_err) = c.call(
"wake_get_session",
json!({ "key": CLAUDE_KEY, "from_seq": from, "max_messages": 2 }),
);
assert!(!is_err, "{page}");
let seqs = seqs_in(&page);
assert!(
!seqs.is_empty(),
"page from {from} rendered nothing:\n{page}"
);
assert_eq!(seqs[0], *seqs.iter().min().unwrap());
visited.extend(seqs);
match next_seq_hint(&page) {
Some(next) => {
assert!(next > from, "next_seq must advance: {from} → {next}");
from = next;
}
None => {
assert!(page.contains("End of transcript."), "{page}");
break;
}
}
}
assert_eq!(
visited, expected_seqs,
"paging must cover every non-Meta message exactly once"
);
let (tools_page, _) = c.call(
"wake_get_session",
json!({ "key": CLAUDE_KEY, "include_tools": true }),
);
assert!(
tools_page.contains("output:"),
"include_tools should add tool output:\n{tools_page}"
);
let (plain_page, _) = c.call("wake_get_session", json!({ "key": CLAUDE_KEY }));
assert!(!plain_page.contains("output:"));
assert!(
plain_page.contains("🔧"),
"tool calls fold to one line by default"
);
// 4b. 子代理转录:作为子会话列在主线页脚(标题是派活时的任务说明),按它自己的 key 读,
// 头部指回父会话;不再在 subagent transcripts 里列第二遍。`subagent` 参数照样按 id 读、
// 同一套分页;未知 id 是给 LLM 看的失败结果并附上有哪些
assert!(
plain_page.contains(
"1 child session (read one with wake_get_session using its key):\n- `claude-code:agent-fixture01` — \"find the QR scanner code\" · 3 messages\n"
),
"{plain_page}"
);
assert!(!plain_page.contains("subagent transcript"), "{plain_page}");
let (child, is_err) = c.call(
"wake_get_session",
json!({ "key": "claude-code:agent-fixture01" }),
);
assert!(!is_err, "{child}");
assert!(
child.contains(&format!("parent: `{CLAUDE_KEY}`")),
"{child}"
);
assert!(child.contains("QR scanner is wired up"), "{child}");
let (sub, is_err) = c.call(
"wake_get_session",
json!({ "key": CLAUDE_KEY, "subagent": "agent-fixture01", "max_messages": 1 }),
);
assert!(!is_err, "{sub}");
assert!(
sub.contains("subagent: agent-fixture01 — Explore: find the QR scanner code"),
"{sub}"
);
assert_eq!(seqs_in(&sub), vec![0]);
assert!(sub.contains("QR scanner is wired up"), "{sub}");
let next = next_seq_hint(&sub).expect("the fixture subagent has three messages");
assert!(
sub.contains(&format!("subagent=\"agent-fixture01\" and from_seq={next}")),
"{sub}"
);
let (rest, _) = c.call(
"wake_get_session",
json!({ "key": CLAUDE_KEY, "subagent": "agent-fixture01", "from_seq": next }),
);
assert!(rest.ends_with("End of subagent transcript.\n"), "{rest}");
assert!(rest.contains("src/qr/scanner.ts"), "{rest}");
let (bad, is_err) = c.call(
"wake_get_session",
json!({ "key": CLAUDE_KEY, "subagent": "agent-nope" }),
);
assert!(is_err);
assert!(bad.contains("- agent-fixture01"), "{bad}");
// `*` 只列清单不读转录(主线页脚封顶 30 条,这里不封顶)
let (all, is_err) = c.call(
"wake_get_session",
json!({ "key": CLAUDE_KEY, "subagent": "*" }),
);
assert!(!is_err, "{all}");
assert!(
all.contains("- agent-fixture01 — Explore: find the QR scanner code"),
"{all}"
);
assert!(!all.contains("### [seq"), "listing only:\n{all}");
// id 是路径形态:参数形状错,协议级 -32602,不去碰文件系统
let reply = c.request(
"tools/call",
json!({ "name": "wake_get_session",
"arguments": { "key": CLAUDE_KEY, "subagent": "../../etc/passwd" } }),
);
assert_eq!(reply["error"]["code"], -32602, "{reply}");
// 5. 项目匹配:cwd 在项目子目录里、没匹配上、项目清单
let (listed, is_err) = c.call(
"wake_list_sessions",
json!({ "project": format!("{CLAUDE_PROJECT}/src/deep"), "agents": ["claude"] }),
);
assert!(!is_err);
assert!(listed.contains(CLAUDE_KEY), "{listed}");
let (nowhere, is_err) = c.call(
"wake_list_sessions",
json!({ "project": "/nowhere/at/all" }),
);
assert!(!is_err, "没匹配上项目不是错误");
assert!(nowhere.contains("No indexed project matches"), "{nowhere}");
assert!(
nowhere.contains(CLAUDE_PROJECT),
"should list known projects:\n{nowhere}"
);
let (projects, _) = c.call("wake_list_projects", json!({}));
assert!(projects.contains(CLAUDE_PROJECT));
// 5b. 记忆:Claude 的 auto-memory 按项目列出,Codex 的用户级不受项目筛选影响;
// wake://memory 引用交给 wake_get_session 读;wake_search 末尾附带记忆命中
let (memories, _) = c.call("wake_list_memories", json!({ "project": CLAUDE_PROJECT }));
assert!(
memories.contains("Wake testing conventions for this repo"),
"{memories}"
);
assert!(
memories.contains("user-preferences"),
"Codex 的用户级记忆不受项目筛选影响:\n{memories}"
);
let mem_ref = memories
.lines()
.find_map(|l| l.trim().strip_prefix("ref: "))
.expect("a wake://memory ref")
.to_string();
assert!(mem_ref.starts_with("wake://memory/"), "{mem_ref}");
let (memory, is_err) = c.call("wake_get_session", json!({ "key": mem_ref }));
assert!(!is_err, "{memory}");
assert!(
memory.starts_with("# ") && memory.contains("source: "),
"{memory}"
);
let (found, _) = c.call("wake_search", json!({ "query": "synthetic" }));
assert!(found.contains("Memory files that mention"), "{found}");
// 项目没匹配上:会话一条都没有,但用户级记忆对每个项目都成立,照样查
let (unmatched, is_err) = c.call(
"wake_search",
json!({ "query": "concise", "project": "/nope/nope" }),
);
assert!(!is_err);
assert!(
unmatched.contains("No indexed project matches")
&& unmatched.contains("Memory files that mention")
&& unmatched.contains("user-preferences"),
"{unmatched}"
);
// 用不可能到达的绝对日期,不用 "1m":fixture 的 updated_at 有的取自文件 mtime,
// Linux 的 fs::copy 不保留 mtime(macOS 走 APFS clone 会保留),staged 的
// fixture 在 Linux 上就是"刚刚"——2026-09-08 CI 只红 ubuntu 那路
let (since_none, _) = c.call("wake_list_sessions", json!({ "since": "2999-01-01" }));
assert!(since_none.starts_with("No sessions"), "{since_none}");
// 6. 坏 key 是给 LLM 看的失败结果,不是协议错误、更不是崩溃
let (missing, is_err) = c.call("wake_get_session", json!({ "key": "claude-code:nope" }));
assert!(is_err);
assert!(missing.contains("No session with key"), "{missing}");
c.finish();
// 7. 全程只读
let after = std::fs::read(&db).unwrap();
assert!(before == after, "wake-mcp must never write the index");
}
/// 只在被要求时使用(#64):`--on-request` 与 WAKE_ON_REQUEST=1 都换上这个模式的说明与工具描述,
/// 都不给是默认那套——拿库里同一份文字比,措辞改了这里不用跟着改
#[test]
fn on_request_mode_tells_agents_to_wait_until_asked() {
let tmp = tempfile::tempdir().unwrap();
let db = tmp.path().join("wake.db");
drop(Store::open(&db).unwrap());
let handshake = |with: &dyn Fn(&mut Command)| {
let mut c = Client::spawn_with(&db, with);
let instructions = c.initialize()["result"]["instructions"].clone();
let tools = c.request("tools/list", json!({}))["result"]["tools"].clone();
c.finish();
(instructions, tools)
};
let expect = |usage| {
(
json!(mcp::instructions(usage)),
json!(tools::definitions_for(usage)),
)
};
assert_eq!(handshake(&|_| {}), expect(Usage::Proactive));
assert_eq!(
handshake(&|cmd| {
cmd.arg("--on-request");
}),
expect(Usage::OnRequest)
);
assert_eq!(
handshake(&|cmd| {
cmd.env(ON_REQUEST_ENV, "1");
}),
expect(Usage::OnRequest)
);
}
#[test]
fn missing_index_exits_with_a_clear_error() {
let tmp = tempfile::tempdir().unwrap();
let out = Command::new(env!("CARGO_BIN_EXE_wake-mcp"))
.arg("--db")
.arg(tmp.path().join("nope.db"))
.stdin(Stdio::null())
.output()
.unwrap();
assert!(!out.status.success());
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("launch Wake once"), "{stderr}");
}