Skip to content

armgit / Wake

Public Imported from GitHub
0

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

Rust
39.1 KB
Raw Blame
//! wake-cli 的端到端契约:合成 fixtures 建临时库 → 起真实 bin → 与进程内
//! `mcp::tools::invoke` 同参数的输出**逐字节**比对(MCP server 跑的正是这个
//! 入口)。docs 与将来的 Skill 因此只需描述一份格式。
//!
//! 参照那一侧故意喂**自然形态**的 JSON(`5` / `true` / `["claude"]`),CLI 那
//! 侧喂字符串与逗号串——同一条断言于是顺带卡住 int_arg 认字符串、agents_arg
//! 认逗号串这两处宽容:谁把它们收紧了,当天就红,而不是 CLI 悄悄开始拒数字。
//!
//! WAKE_HOME/HOME 是进程级环境且子进程继承它:fixture home 只建一次
//! (OnceLock)、全文件共用;不碰 home 的用例(缺库 / --help)照常并行。

use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::{Arc, OnceLock};

use serde_json::{json, Value};
use wake_core::adapters::{create_adapter_roster_for, create_adapters_for, AgentAdapter};
use wake_core::cli;
use wake_core::db::{self, Store};
use wake_core::mcp::tools::{self, TranscriptCache};
use wake_core::mcp::ON_REQUEST_ENV;
use wake_core::models::{AgentId, Role, SessionFilter, SessionMeta};
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";
/// 绝对日期,不用 7d 这类相对量:fs::copy 在 Linux 上不保留 mtime,fixture 在
/// 那边全是"刚刚",相对窗口两平台结果不同(2026-09-08 让 CI 红过一次)
const ALWAYS: &str = "2000-01-01";
const NEVER: &str = "2999-01-01";

struct TestEnv {
    db: PathBuf,
    _home: tempfile::TempDir, // TempDir 必须被持有,否则整进程期间被清掉
}

static ENV: OnceLock<TestEnv> = OnceLock::new();

fn env() -> &'static TestEnv {
    ENV.get_or_init(|| {
        let tmp = tempfile::Builder::new()
            .prefix("wake-cli-e2e-")
            .tempdir()
            .unwrap();
        let home = tmp.path().join("home");
        common::stage_dir_fixtures(&home);
        common::stage_sidecars(&home);
        common::isolate_home(&home); // 必须在任何 adapter 构造之前
        let db = tmp.path().join("wake.db");
        {
            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();
            assert!(
                total > 10,
                "fixture home should index many sessions ({total})"
            );
        } // 块尾关写连接:最后一个连接 checkpoint,-wal/-shm 消失,之后
          // open_read_only 与字节快照才稳定
        TestEnv { db, _home: tmp }
    })
}

/// 参照侧:与 bin 同一条打开路径、同一份 roster
fn store_and_roster() -> (Store, Vec<Box<dyn AgentAdapter>>) {
    let store = Store::open_read_only(&env().db).expect("read-only open");
    let adapters = create_adapters_for(&store);
    (store, adapters)
}

fn call(
    store: &Store,
    adapters: &[Box<dyn AgentAdapter>],
    tool: &str,
    args: &Value,
) -> Result<String, tools::ToolError> {
    tools::invoke(store, adapters, &TranscriptCache::default(), tool, args)
}

fn cli_raw(args: &[&str]) -> (String, String, Option<i32>) {
    cli_raw_with(args, |_| {})
}

/// 唯一的 spawn 实现(`with` 改环境与工作目录)。不要 .env_clear():子进程的
/// roster 全靠继承 WAKE_HOME/HOME
fn cli_raw_with(args: &[&str], with: impl FnOnce(&mut Command)) -> (String, String, Option<i32>) {
    let mut cmd = Command::new(env!("CARGO_BIN_EXE_wake-cli"));
    cmd.args(args);
    with(&mut cmd);
    let out = cmd.output().expect("spawn wake-cli");
    (
        String::from_utf8(out.stdout).expect("stdout is utf-8"),
        String::from_utf8(out.stderr).expect("stderr is utf-8"),
        out.status.code(),
    )
}

/// 冲着 fixture 库跑
fn cli_run(args: &[&str]) -> (String, String, Option<i32>) {
    let db = env().db.to_str().expect("tmp path is utf-8");
    cli_raw(&[&["--db", db], args].concat())
}

/// argv 跑出来的东西必须与同参数的工具文本逐字节相同
fn same(
    (store, adapters): &(Store, Vec<Box<dyn AgentAdapter>>),
    argv: &[&str],
    tool: &str,
    natural: Value,
) {
    let text = call(store, adapters, tool, &natural).expect("tool ok");
    // CLI 最多补一个换行:search/sessions/projects 收在 index_note 上、无换行,
    // get_session 自带。用算出来的期望值精确相等,不要 trim_end——那会把工具
    // 文本自带的尾换行一起吃掉、把差异藏起来
    let want = if text.ends_with('\n') {
        text
    } else {
        format!("{text}\n")
    };
    let (stdout, stderr, code) = cli_run(argv);
    assert_eq!(code, Some(0), "argv {argv:?} 应当成功: {stderr}");
    assert_eq!(stderr, "", "argv {argv:?} 跑通时 stderr 必须一个字节都没有");
    assert_eq!(stdout, want, "argv {argv:?} 必须原样吐工具文本");
}

/// 每条 argv 与它对应的自然形态参数。测试 2 会走这张表核对旗标覆盖率
fn argv(a: &[&str]) -> Vec<String> {
    a.iter().map(|s| s.to_string()).collect()
}

fn cases() -> Vec<(Vec<String>, &'static str, Value)> {
    let reference = format!("wake://session/{CLAUDE_KEY}#3");
    vec![
        (
            argv(&["search", "二维码", "--limit", "3"]),
            tools::SEARCH,
            json!({"query":"二维码","limit":3}),
        ),
        (
            argv(&[
                "search",
                "二维码",
                "--project",
                CLAUDE_PROJECT,
                "--agent",
                "claude",
                "--since",
                ALWAYS,
                "--limit",
                "2",
            ]),
            tools::SEARCH,
            json!({"query":"二维码","project":CLAUDE_PROJECT,"agents":["claude"],"since":ALWAYS,"limit":2}),
        ),
        (
            argv(&["sessions", "--limit", "5"]),
            tools::LIST_SESSIONS,
            json!({"limit":5}),
        ),
        (
            argv(&[
                "sessions",
                "--project",
                CLAUDE_PROJECT,
                "--agent",
                "claude,codex",
                "--starred",
                "--since",
                ALWAYS,
                "--limit",
                "3",
            ]),
            tools::LIST_SESSIONS,
            json!({"project":CLAUDE_PROJECT,"agents":["claude","codex"],"starred":true,
                   "since":ALWAYS,"limit":3}),
        ),
        (
            argv(&[
                "show",
                CLAUDE_KEY,
                "--from",
                "1",
                "--messages",
                "2",
                "--chars",
                "5000",
                "--message-chars",
                "500",
                "--tools",
                "--thinking",
            ]),
            tools::GET_SESSION,
            json!({"key":CLAUDE_KEY,"from_seq":1,"max_messages":2,"max_chars":5000,
                   "max_message_chars":500,"include_tools":true,"include_thinking":true}),
        ),
        (
            argv(&["show", &reference]),
            tools::GET_SESSION,
            json!({ "key": reference }),
        ),
        (
            argv(&[
                "show",
                CLAUDE_KEY,
                "--subagent",
                "agent-fixture01",
                "--messages",
                "2",
            ]),
            tools::GET_SESSION,
            json!({"key":CLAUDE_KEY,"subagent":"agent-fixture01","max_messages":2}),
        ),
        (
            argv(&["projects", "--since", ALWAYS, "--limit", "10"]),
            tools::LIST_PROJECTS,
            json!({"since":ALWAYS,"limit":10}),
        ),
        (
            argv(&[
                "memories",
                "--project",
                CLAUDE_PROJECT,
                "--agent",
                "claude-code",
                "--limit",
                "10",
            ]),
            tools::LIST_MEMORIES,
            json!({"project":CLAUDE_PROJECT,"agents":["claude-code"],"limit":10}),
        ),
    ]
}

#[test]
fn every_command_prints_the_tool_text_verbatim() {
    let reference = store_and_roster();
    for (args, tool, natural) in cases() {
        let args: Vec<&str> = args.iter().map(String::as_str).collect();
        same(&reference, &args, tool, natural);
    }
}

/// 每个命令、每个旗标都被上面那张表真正跑过一次。与 cli.rs 里的双射单测合起
/// 来,"工具新增参数不可能未经测试地发版"才是真的,不是口号
#[test]
fn every_command_and_flag_is_exercised_end_to_end() {
    let cases = cases();
    for c in cli::COMMANDS {
        let used: Vec<&Vec<String>> = cases
            .iter()
            .filter(|(argv, _, _)| argv.first().map(String::as_str) == Some(c.name))
            .map(|(argv, _, _)| argv)
            .collect();
        assert!(!used.is_empty(), "命令 {} 没有端到端用例", c.name);
        for f in c.flags {
            assert!(
                used.iter().any(|argv| argv.iter().any(|a| a == f.long)),
                "{} 的 {} 没有端到端用例",
                c.name,
                f.long
            );
        }
    }
}

/// 退出码那道决定的全部:argv 敲错与工具认为值不对,对用户是同一件事,都退 2
#[test]
fn bad_arguments_exit_two_and_name_the_problem() {
    for (argv, needle) in [
        (
            vec!["sessions", "--since", "yesterday"],
            "`since` not understood",
        ),
        (vec!["sessions", "--agent", "chatgpt"], "unknown agent"),
        (vec!["sessions", "--limit", "abc"], "must be an integer"),
        (vec!["nope"], "unknown command"),
        (vec!["sessions", "--nope"], "unknown option"),
        (vec!["sessions", "--starred=false"], "takes no value"),
        (vec!["search"], "needs a QUERY"),
        (vec!["show"], "needs a KEY"),
        (
            vec!["search", "x", "--starred"],
            "only valid for `sessions`",
        ),
        (vec!["sessions", "--project", "."], "$PWD"),
        (vec!["sessions", "myproj"], "takes no arguments"),
    ] {
        let (stdout, stderr, code) = cli_run(&argv);
        assert_eq!(code, Some(2), "argv {argv:?} 应当退 2: {stderr}");
        assert!(stdout.is_empty(), "argv {argv:?} 出错时 stdout 必须为空");
        assert!(
            stderr.contains(needle),
            "argv {argv:?} 的 stderr 应当提到 {needle:?},实际是 {stderr}"
        );
        assert!(stderr.starts_with("wake-cli: "), "{stderr}");
    }
    // 缺命令走的是另一条:parse 直接给 "needs a command"
    let (_, stderr, code) = cli_run(&[]);
    assert_eq!(code, Some(2));
    assert!(stderr.contains("needs a command"), "{stderr}");
}

/// 读不出来的会话是"跑起来了然后失败",退 1,且文本与 MCP 那侧同源
#[test]
fn unreadable_session_exits_one() {
    let (store, adapters) = store_and_roster();
    let want = match call(
        &store,
        &adapters,
        tools::GET_SESSION,
        &json!({"key":"claude-code:nope"}),
    ) {
        Err(tools::ToolError::Failed(m)) => m,
        other => panic!("坏 key 应当是 ToolError::Failed,实际 {other:?}"),
    };
    let (stdout, stderr, code) = cli_run(&["show", "claude-code:nope"]);
    assert_eq!(code, Some(1));
    assert!(stdout.is_empty());
    assert_eq!(stderr, format!("wake-cli: {want}\n"));
}

/// 空结果不是错误:`wake-cli search x || fallback` 不能因为"这事没讨论过"就触发
#[test]
fn no_results_is_success() {
    for (argv, prefix) in [
        (vec!["search", "zzqqxx-no-such-term"], "No session matches"),
        (
            vec!["sessions", "--project", "/nope/nope"],
            "No indexed project matches",
        ),
        (vec!["sessions", "--since", NEVER], "No sessions"),
        (vec!["projects", "--since", NEVER], "No projects"),
        (
            vec!["memories", "--project", "/nope/nope"],
            "No indexed project matches",
        ),
    ] {
        let (stdout, stderr, code) = cli_run(&argv);
        assert_eq!(code, Some(0), "argv {argv:?}: {stderr}");
        assert!(stdout.starts_with(prefix), "argv {argv:?} 输出是 {stdout}");
    }
    let (stdout, _, code) = cli_run(&["show", CLAUDE_KEY, "--from", "9999"]);
    assert_eq!(code, Some(0));
    assert!(
        stdout.contains("No messages at or after seq 9999"),
        "{stdout}"
    );
}

/// 超范围的数字由 int_arg 裁剪,不是 CLI 拒绝——CLI 若自己校验就会与 MCP 分家
#[test]
fn out_of_range_limits_are_clamped_not_rejected() {
    let reference = store_and_roster();
    same(
        &reference,
        &["sessions", "--limit", "999"],
        tools::LIST_SESSIONS,
        json!({"limit":100}),
    );
    same(
        &reference,
        &["search", "二维码", "--limit", "0"],
        tools::SEARCH,
        json!({"query":"二维码","limit":1}),
    );
}

/// 这三条不碰 fixture home,与别的用例并行也安全:--help/--version 根本不开库,
/// 缺库那条在建 roster 之前就退了,而且都显式带 --db,不会触发
/// default_db_path() 的首次迁移副作用
#[test]
fn missing_index_and_help_need_no_fixture_home() {
    let tmp = tempfile::tempdir().unwrap();
    let missing = tmp.path().join("nope.db");
    let (stdout, stderr, code) = cli_raw(&["--db", missing.to_str().unwrap(), "sessions"]);
    assert_eq!(code, Some(2));
    assert!(stdout.is_empty());
    assert!(stderr.contains("launch Wake once"), "{stderr}");

    let (stdout, stderr, code) = cli_raw(&["--help"]);
    assert_eq!(code, Some(0));
    assert_eq!(stderr, "");
    assert_eq!(stdout, format!("{}\n", cli::help()));

    let (stdout, _, code) = cli_raw(&["--version"]);
    assert_eq!(code, Some(0));
    assert_eq!(stdout, format!("wake-cli {}\n", env!("CARGO_PKG_VERSION")));
}

/// setup 不是工具调用,上面那张 cases 表结构上覆盖不到它
#[test]
fn setup_reports_the_binary_and_never_fails() {
    let (stdout, stderr, code) = cli_run(&["setup"]);
    assert_eq!(code, Some(0), "{stderr}");
    assert!(stdout.contains("wake-cli binary: "), "{stdout}");
    assert!(stdout.contains(env!("CARGO_BIN_EXE_wake-cli")), "{stdout}");
    assert!(stdout.contains("--project \"$PWD\""), "{stdout}");
    // 库缺失也照样退 0:"还没装好"正是跑 setup 的人的处境
    let tmp = tempfile::tempdir().unwrap();
    let missing = tmp.path().join("nope.db");
    let (stdout, _, code) = cli_raw(&["--db", missing.to_str().unwrap(), "setup"]);
    assert_eq!(code, Some(0));
    assert!(
        stdout.trim_end().ends_with("launch Wake once to build it"),
        "{stdout}"
    );
}

/// Linux 上目录名可以不是 UTF-8,而 `--project "$PWD"` 正是主用法:
/// std::env::args() 会 panic 成 101,args_os 才能给出契约内的退出码
#[cfg(unix)]
#[test]
fn non_utf8_arguments_exit_two_instead_of_panicking() {
    use std::ffi::OsStr;
    use std::os::unix::ffi::OsStrExt;

    let out = Command::new(env!("CARGO_BIN_EXE_wake-cli"))
        .arg("sessions")
        .arg("--project")
        .arg(OsStr::from_bytes(b"/tmp/caf\xe9"))
        .output()
        .expect("spawn wake-cli");
    assert_eq!(out.status.code(), Some(2));
    let stderr = String::from_utf8_lossy(&out.stderr);
    assert!(
        stderr.starts_with("wake-cli: argument is not valid UTF-8"),
        "{stderr}"
    );
}

/// SKILL.md 是 CLI 的第二张脸:CLI 改了而它没跟上,agent 就会照着过时的说明
/// 去敲命令。frontmatter 齐、四个子命令全提到、退出码那条约定在,少一样就红
#[test]
fn the_skill_stays_in_sync_with_the_cli() {
    let path = Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("../../skills/wake/SKILL.md")
        .canonicalize()
        .expect("skills/wake/SKILL.md 必须存在——它是 `npx skills add` 装的东西");
    let md = std::fs::read_to_string(&path).expect("read SKILL.md");

    // frontmatter:name 与 description 是懒加载时常驻上下文的那两行。
    // **一律按 `lines()` 切**(它同时吃 \n 与 \r\n):仓库没有 .gitattributes,
    // Windows CI 按 core.autocrlf=true 检出的 SKILL.md 是 CRLF,硬比 "---\n"
    // 会让这条测试在三平台里只红一个
    let mut lines = md.lines();
    assert_eq!(
        lines.next(),
        Some("---"),
        "SKILL.md 要以 YAML frontmatter 开头"
    );
    let front: Vec<&str> = lines.by_ref().take_while(|l| *l != "---").collect();
    assert!(lines.next().is_some(), "frontmatter 要闭合,后面还要有正文");
    assert!(front.contains(&"name: wake"), "frontmatter 缺 name");
    let desc = front
        .iter()
        .find_map(|l| l.strip_prefix("description: "))
        .expect("frontmatter 缺单行的 `description: …`");
    // description 是触发条件,不是名词解释——没有 "Use when" 就等于没有触发器
    assert!(
        desc.contains("Use when"),
        "description 要写成触发条件: {desc}"
    );

    for c in cli::COMMANDS {
        assert!(
            md.contains(&format!("wake-cli {}", c.name)),
            "SKILL.md 没有 `wake-cli {}` 的例子",
            c.name
        );
    }
    // 最容易被误读的两条约定
    assert!(
        md.contains("--project \"$PWD\""),
        "SKILL.md 要交代 --project 的约定"
    );
    assert!(md.contains("wake://session/"), "SKILL.md 要交代引用格式");
    assert!(md.contains("read-only"), "SKILL.md 要声明只读");
}

/// 一旦有人把 open_or_rebuild 摸进来,或者把 `index` 那道口子放宽到已存在的
/// 库上,这条就红
#[test]
fn the_cli_never_writes_an_index_that_exists() {
    let db = &env().db;
    let before = std::fs::read(db).unwrap();
    for argv in [
        vec!["sessions", "--limit", "3"],
        vec!["search", "二维码"],
        vec!["show", CLAUDE_KEY],
        vec!["projects"],
        // index 对**已存在**的库同样不许动一个字节——那道口子只开给"库不存在"
        vec!["index"],
    ] {
        let (_, stderr, code) = cli_run(&argv);
        assert_eq!(code, Some(0), "{stderr}");
    }
    assert!(
        before == std::fs::read(db).unwrap(),
        "wake-cli must never write an index that already exists"
    );
}

/// 这条口子存在的唯一理由:装了 Wake 但从没启动过。库不存在时建一次、建完
/// 立刻可查;库已存在就退让(字节不变那一半由上面那条卡)。
///
/// **先 `env()` 再 spawn**:它建 fixture home 并钉住 WAKE_HOME/HOME 给子进程
/// 继承。不走这一步,子进程扫的就是维护者真实的家目录——本机十秒、还把真实
/// 索引整个拷进 tempdir,而 CI 上家目录是空的,`starts_with("Indexed ")` 对
/// "Indexed 0 sessions" 照样为真,整条用例空过
#[test]
fn index_builds_one_from_scratch_then_defers() {
    let want = Store::open_read_only(&env().db)
        .unwrap()
        .list_sessions(&SessionFilter {
            limit: 1,
            ..Default::default()
        })
        .unwrap()
        .1;
    let tmp = tempfile::tempdir().unwrap();
    let db = tmp.path().join("fresh.db");
    // 主库不在、边车还躺着(主库被手删,或 open_or_rebuild 崩在挪库与删边车
    // 之间):留下任何一个,新库都会接着读旧日志
    for suffix in ["-wal", "-shm"] {
        std::fs::write(format!("{}{suffix}", db.display()), b"stale").unwrap();
    }

    let (stdout, stderr, code) = cli_raw(&["--db", db.to_str().unwrap(), "index"]);
    assert_eq!(code, Some(0), "{stderr}");
    assert!(db.is_file(), "应当真的建出库来");
    // 扫描落在 <db>.build-<pid>;占位成功后那个名字必须收干净,不然一次运行就
    // 在用户的索引目录里留下几百 MB
    let names: Vec<String> = std::fs::read_dir(tmp.path())
        .unwrap()
        .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
        .collect();
    assert!(
        !names.iter().any(|n| n.contains(".build-")),
        "临时库没收干净:{names:?}"
    );
    // 孤儿边车必须被清掉。之后的只读连接会自己再建一个 -shm,所以判据是
    // "还在不在" 之外那一条:planted 的内容不许活下来
    for suffix in ["-wal", "-shm"] {
        let p = format!("{}{suffix}", db.display());
        if let Ok(bytes) = std::fs::read(&p) {
            assert_ne!(bytes, b"stale", "{p} 还是那份孤儿日志");
        }
    }
    // 这个功能的主张就是这一句:CLI 自己建的索引 == GUI 从同一棵树建的那个
    assert!(
        stdout.starts_with(&format!("Indexed {want} session")),
        "应当与 fixture 库同样收录 {want} 条:{stdout}"
    );

    // 建完就能查,不必先启动 GUI
    let (stdout, _, code) = cli_raw(&["--db", db.to_str().unwrap(), "projects"]);
    assert_eq!(code, Some(0));
    assert!(stdout.contains(CLAUDE_PROJECT), "{stdout}");

    // 第二次是退让,不是重建
    let (stdout, _, code) = cli_raw(&["--db", db.to_str().unwrap(), "index"]);
    assert_eq!(code, Some(0));
    assert!(stdout.starts_with("An index already exists"), "{stdout}");
}

/// refresh 用的库副本:主库是全文件共用的只读参照,别的用例正拿它做字节比对,
/// 刷新只能冲着自己那份拷贝跑(扫的仍是共用的 fixture home,只读)
fn db_copy(dir: &Path) -> PathBuf {
    let db = dir.join("copy.db");
    std::fs::copy(&env().db, &db).unwrap();
    db
}

/// 这个功能的主张:app 不开,`refresh` 也把索引追到磁盘的现状。抠掉一行(不留
/// 墓碑,scanner 删磁盘已删的会话用的正是这一手),文件还在,刷新该把它收回来——
/// 不往共用的 fixture home 里加文件,那会让并行的 index 用例数出别的数
#[test]
fn refresh_brings_an_existing_index_up_to_date() {
    let tmp = tempfile::tempdir().unwrap();
    let db = db_copy(tmp.path());
    let path = db.to_str().unwrap();
    Store::open(&db)
        .unwrap()
        .remove_session(CLAUDE_KEY)
        .unwrap();
    let (_, _, code) = cli_raw(&["--db", path, "show", CLAUDE_KEY, "--messages", "1"]);
    assert_eq!(code, Some(1), "抠掉的会话按 key 该是读不出来的");

    let (stdout, stderr, code) = cli_raw(&["--db", path, "refresh"]);
    assert_eq!(code, Some(0), "{stderr}");
    assert_eq!(stderr, "", "管道里跑,stderr 保持安静");
    assert!(stdout.starts_with("Refreshed the index at "), "{stdout}");
    assert!(stdout.contains(" sessions from "), "{stdout}");

    let (_, stderr, code) = cli_raw(&["--db", path, "show", CLAUDE_KEY, "--messages", "1"]);
    assert_eq!(code, Some(0), "刷新后该收回来:{stderr}");
}

/// 只在 Wake 没运行时干活:GUI 持锁就直说它在跑,另一个 wake-cli 持锁就点名,
/// 两种退让都退 0 且库一个字节不动;锁一放就能刷
#[test]
fn refresh_defers_while_the_index_is_held() {
    let tmp = tempfile::tempdir().unwrap();
    let db = db_copy(tmp.path());
    let path = db.to_str().unwrap();
    let before = std::fs::read(&db).unwrap();
    let refresh = || cli_raw(&["--db", path, "refresh"]);
    for (kind, expect) in [
        (db::LOCK_KIND_APP, "Wake is running"),
        (
            "wake-cli refresh",
            "Another process is writing the index right now (wake-cli refresh ",
        ),
    ] {
        let _lock = common::lock_as(&db, kind);
        let (stdout, stderr, code) = refresh();
        assert_eq!(code, Some(0), "{stderr}");
        assert!(stdout.starts_with(expect), "{stdout}");
        assert_eq!(before, std::fs::read(&db).unwrap(), "退让时一个字节不许动");
    }
    let (stdout, stderr, code) = refresh();
    assert_eq!(code, Some(0), "{stderr}");
    assert!(stdout.starts_with("Refreshed the index at "), "{stdout}");
}

/// 没索引不是 refresh 的事(`index` 或启动 Wake 才建),与查询命令缺库同退 2,
/// 而且什么都不该建——连锁文件都不留
#[test]
fn refresh_without_an_index_exits_two() {
    let tmp = tempfile::tempdir().unwrap();
    let db = tmp.path().join("none.db");
    let (stdout, stderr, code) = cli_raw(&["--db", db.to_str().unwrap(), "refresh"]);
    assert_eq!(code, Some(2));
    assert_eq!(stdout, "");
    assert!(
        stderr.starts_with("wake-cli: no Wake index at "),
        "{stderr}"
    );
    assert!(
        stderr.contains("wake-cli index"),
        "该指向建库的那条命令:{stderr}"
    );
    let left: Vec<_> = std::fs::read_dir(tmp.path())
        .unwrap()
        .map(|e| e.unwrap().file_name())
        .collect();
    assert!(
        left.is_empty(),
        "没索引就什么都不该建,连锁文件与持有者旁路都不该留:{left:?}"
    );
}

/// `index` 也认这把锁:GUI 正在启动(下一步就是自己建库)时退让,不建、退 0
#[test]
fn index_defers_while_wake_holds_the_index() {
    let tmp = tempfile::tempdir().unwrap();
    let db = tmp.path().join("fresh.db");
    let _lock = common::lock_as(&db, db::LOCK_KIND_APP);
    let (stdout, stderr, code) = cli_raw(&["--db", db.to_str().unwrap(), "index"]);
    assert_eq!(code, Some(0), "{stderr}");
    assert!(stdout.starts_with("Wake is running"), "{stdout}");
    assert!(!db.exists(), "退让就不该建库");
}

/// `--db` 指错到别家 SQLite(Cursor 的 state.vscdb 一类):一个字节不许动——别家数据只读是
/// 铁律——退 2 说清楚,连锁文件都不留(Codex review 2026-09-23)
#[test]
fn refresh_refuses_a_database_that_is_not_a_wake_index() {
    let tmp = tempfile::tempdir().unwrap();
    let foreign = tmp.path().join("state.vscdb");
    rusqlite::Connection::open(&foreign)
        .unwrap()
        .execute_batch("CREATE TABLE ItemTable (key TEXT PRIMARY KEY, value BLOB);")
        .unwrap();
    let before = std::fs::read(&foreign).unwrap();
    let (stdout, stderr, code) = cli_raw(&["--db", foreign.to_str().unwrap(), "refresh"]);
    assert_eq!(code, Some(2), "{stderr}");
    assert_eq!(stdout, "");
    assert!(stderr.contains("is not a Wake index"), "{stderr}");
    assert_eq!(
        before,
        std::fs::read(&foreign).unwrap(),
        "别家库一个字节不许动"
    );
    let names: Vec<String> = std::fs::read_dir(tmp.path())
        .unwrap()
        .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
        .collect();
    assert!(!names.iter().any(|n| n.contains(".lock")), "{names:?}");
}

/// 有远程会话入库、镜像目录却不在这条路径旁 = 给的不是 GUI 开它的那条路径(真库的别名,
/// 或被链接到别处的真库本身):照扫会把远程会话整批当"磁盘已删"清掉,拒掉、退 2、行还在
/// (Codex review 2026-09-23)
#[test]
fn refresh_refuses_a_path_whose_remote_mirrors_are_elsewhere() {
    let tmp = tempfile::tempdir().unwrap();
    let db = db_copy(tmp.path());
    Store::open(&db).unwrap().add_remote_host("box").unwrap();
    // 直接塞一行远程会话:这条路径旁没有 remotes/box
    rusqlite::Connection::open(&db)
        .unwrap()
        .execute(
            "INSERT INTO sessions(key, agent_id, native_id, host, file_path) \
             VALUES ('codex:box:abc', 'codex', 'abc', 'box', '/elsewhere/remotes/box/x.jsonl')",
            [],
        )
        .unwrap();
    let (stdout, stderr, code) = cli_raw(&["--db", db.to_str().unwrap(), "refresh"]);
    assert_eq!(code, Some(2), "{stderr}");
    assert_eq!(stdout, "");
    assert!(stderr.contains("mirrors are not next to it"), "{stderr}");
    let left: i64 = rusqlite::Connection::open(&db)
        .unwrap()
        .query_row(
            "SELECT COUNT(*) FROM sessions WHERE host = 'box'",
            [],
            |r| r.get(0),
        )
        .unwrap();
    assert_eq!(left, 1, "远程会话不许被清掉");
}

/// 同上,但这台 host 只剩远程记忆、没有会话行(转录清掉了、Codex 记忆还在):镜像不在照样
/// 拒,否则 `sync_memories` 会把它的记忆当消失的来源整组删掉(Codex review 2026-09-23)
#[test]
fn refresh_refuses_when_only_remote_memories_would_be_lost() {
    let tmp = tempfile::tempdir().unwrap();
    let db = db_copy(tmp.path());
    Store::open(&db).unwrap().add_remote_host("box").unwrap();
    rusqlite::Connection::open(&db)
        .unwrap()
        .execute(
            "INSERT INTO memories(key, agent_id, host, scope, path, title, body) \
             VALUES ('codex:box:/elsewhere/m.md', 'codex', 'box', 'user', '/elsewhere/m.md', 'm', 'x')",
            [],
        )
        .unwrap();
    let (stdout, stderr, code) = cli_raw(&["--db", db.to_str().unwrap(), "refresh"]);
    assert_eq!(code, Some(2), "{stderr}");
    assert_eq!(stdout, "");
    assert!(stderr.contains("mirrors are not next to it"), "{stderr}");
    let left: i64 = rusqlite::Connection::open(&db)
        .unwrap()
        .query_row(
            "SELECT COUNT(*) FROM memories WHERE host = 'box'",
            [],
            |r| r.get(0),
        )
        .unwrap();
    assert_eq!(left, 1, "远程记忆不许被清掉");
}

/// `context` 给 SessionStart 钩子用:当前目录所在项目最近两周、各个 agent 停在哪(最后一问、
/// 最后一答),子目录归到所在项目。每个 agent 先各取一条再按时间补满五条——常用的那一家
/// 不能把别家挤出去;一句提问都没有的会话不列。认不出项目、两周内没有会话时一个字节都不
/// 输出、退 0——钩子的输出原样进 agent 的上下文。家目录不当"所在项目":在家目录随手开的
/// 会话不该被塞进每个新项目
#[test]
fn context_shows_where_each_agent_left_off_or_nothing() {
    let tmp = tempfile::tempdir().unwrap();
    let home = common::real_dir(tmp.path());
    let project = home.join("app");
    let fresh = home.join("fresh");
    std::fs::create_dir_all(project.join("src")).unwrap();
    std::fs::create_dir_all(&fresh).unwrap();
    let db = home.join("wake.db");
    {
        let store = Store::open(&db).unwrap();
        let now = db::now_ms();
        let write = |key: &str, at: &Path, minutes_ago: i64, turns: &[(Role, &str)]| {
            let updated_at = now - minutes_ago * 60_000;
            let meta = SessionMeta {
                agent: AgentId::from_str(key.split(':').next().unwrap()).unwrap(),
                project_path: at.to_string_lossy().into_owned(),
                created_at: updated_at,
                updated_at,
                ..common::meta(key, &format!("about {key}"))
            };
            let units: Vec<_> = turns
                .iter()
                .enumerate()
                .map(|(seq, (role, text))| common::unit(seq as i64, *role, text))
                .collect();
            store.write_session(&meta, updated_at, &units).unwrap();
        };
        // Claude Code 五条都比 Codex 那条新,只按时间挑 Codex 就进不来。每条最后一个用户单元
        // 是 `/model` 一类命令的输出——不是人说的话,最后一问要往前找到真正的提问
        for n in 1..=5 {
            write(
                &format!("claude-code:c{n}"),
                &project,
                n,
                &[
                    (Role::User, &format!("ask c{n}")),
                    (Role::Assistant, &format!("did c{n}\nmore")),
                    (
                        Role::User,
                        "<local-command-stdout>Set model to opus</local-command-stdout>",
                    ),
                ],
            );
        }
        write(
            "codex:review",
            &project,
            2 * 24 * 60,
            &[
                (
                    Role::User,
                    "<command-message>review</command-message>\n<command-name>/review</command-name>\n<command-args>--base main</command-args>",
                ),
                (Role::Assistant, "Looks good overall"),
                // 只有工具调用的消息:单元以换行开头,不算回复
                (Role::Assistant, "\nBash git diff main"),
            ],
        );
        // 一句提问都没有(别的 agent 代跑、刚开还没说话)
        write("codex:silent", &project, 0, &[(Role::Assistant, "working")]);
        write(
            "claude-code:stale",
            &project,
            30 * 24 * 60,
            &[(Role::User, "old")],
        );
        write("claude-code:in-home", &home, 0, &[(Role::User, "hi")]);
    }
    // 跑测试的环境里设了 WAKE_ON_REQUEST 也清掉,默认那套才是确定的
    let context_with = |dir: &Path, on_request: Option<&str>| {
        cli_raw_with(&["--db", db.to_str().unwrap(), "context"], |cmd| {
            cmd.env("WAKE_HOME", &home)
                .env_remove(ON_REQUEST_ENV)
                .current_dir(dir);
            if let Some(value) = on_request {
                cmd.env(ON_REQUEST_ENV, value);
            }
        })
    };
    let context = |dir: &Path| {
        let (out, _, code) = context_with(dir, None);
        (out, code)
    };
    let (text, code) = context(&project.join("src"));
    assert_eq!(code, Some(0));
    assert!(
        text.starts_with(
            "Wake: recent sessions in this project, across your coding agents (5 of 7 from the last 14 days):"
        ),
        "{text}"
    );
    let at = |needle: &str| {
        text.find(needle)
            .unwrap_or_else(|| panic!("{needle} 不在: {text}"))
    };
    // 按时间排:c1 最新,Codex 那条最旧
    assert!(
        at("`claude-code:c1`") < at("`claude-code:c4`")
            && at("`claude-code:c4`") < at("`codex:review`")
    );
    assert!(
        !text.contains("claude-code:c5"),
        "补满五条,c5 排不上: {text}"
    );
    assert!(
        text.contains("last asked: \"ask c1\"\n  last reply: \"did c1\"\n"),
        "{text}"
    );
    assert!(
        text.contains("last asked: \"/review --base main\""),
        "slash 命令写回原样: {text}"
    );
    assert!(
        text.contains("last reply: \"Looks good overall\""),
        "工具调用不算回复: {text}"
    );
    assert!(!text.contains("codex:silent"), "没有提问的会话不列: {text}");
    assert!(!text.contains("stale"), "两周以前的不列: {text}");
    assert!(!text.contains("in-home"), "家目录的会话不跟进来: {text}");

    let elsewhere = tempfile::tempdir().unwrap();
    for dir in [fresh.as_path(), elsewhere.path()] {
        assert_eq!(context(dir), (String::new(), Some(0)), "{}", dir.display());
    }

    // 只在被要求时使用(#64):开会话什么都不加,stderr 那句只给在终端里自己跑的人看;写 0 是关
    let (out, err, code) = context_with(&project, Some("1"));
    assert_eq!((out.as_str(), code), ("", Some(0)));
    assert!(err.contains(ON_REQUEST_ENV), "{err}");
    assert_eq!(context_with(&project, Some("0")).0, text);
}

/// 插件只是一层壳:清单、钩子、MCP 配置都指向仓库里真实存在的脚本,钩子调的是 `wake-cli
/// context`,启动脚本找的正是各平台打包落下二进制的地方。Claude Code 与 Codex 共用一个插件
/// 目录,各读各的清单与市场文件。`claude plugin validate` 与 Codex 都不在 CI 里跑,这里卡住
/// 最容易漂的几处
#[test]
fn the_plugins_point_at_real_files() {
    let repo = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
    let json = |path: PathBuf| -> Value {
        serde_json::from_str(&std::fs::read_to_string(path).unwrap()).unwrap()
    };
    // 安装命令最后一段 `<插件>@<市场>` 与市场文件对得上
    let install_id = |market: &Value| {
        format!(
            "{}@{}",
            market["plugins"][0]["name"].as_str().unwrap(),
            market["name"].as_str().unwrap()
        )
    };
    let market = json(repo.join(".claude-plugin/marketplace.json"));
    let entry = &market["plugins"][0];
    assert!(cli::CLAUDE_PLUGIN_INSTALL.ends_with(&install_id(&market)));
    let plugin = repo.join(entry["source"].as_str().unwrap());
    let manifest = json(plugin.join(".claude-plugin/plugin.json"));
    assert_eq!(manifest["name"], entry["name"]);

    // 钩子两家共用,整份钉死:Codex 按这份定义(matcher、命令、超时)认信任,改一个字所有
    // Codex 用户的钩子就停了、要去 /hooks 重新信任——行为上的改动放进 scripts/session-start
    assert_eq!(
        json(plugin.join("hooks/hooks.json")),
        json!({ "hooks": { "SessionStart": [{
            "matcher": "startup|clear",
            "hooks": [{
                "type": "command",
                "command": "sh \"${CLAUDE_PLUGIN_ROOT}/scripts/session-start\"",
                "timeout": 30
            }]
        }]}})
    );
    let start = std::fs::read_to_string(plugin.join("scripts/session-start")).unwrap();
    assert!(start.contains("wake-cli context"), "{start}");

    // MCP 两家各写一份:Claude Code 的 stdio 配置没有 cwd、插件路径靠 ${CLAUDE_PLUGIN_ROOT};
    // Codex 不展开 MCP 参数里的变量(只展开钩子命令),写相对路径 + cwd "."(插件根,Codex
    // 自带的插件也这么写),直接放在清单里。Codex 只给 MCP 子进程几个默认环境变量(PATH、
    // HOME 这些),启动脚本认的 WAKE_BIN_DIR 要点名放行,不然 Wake 装在别处的人钩子能用、
    // MCP 却找不到 wake-mcp;WAKE_ON_REQUEST 同理,不放行 wake-mcp 就看不见它
    let mcp = json(plugin.join(".mcp.json"));
    let args = &mcp["mcpServers"]["wake"]["args"];
    assert_eq!(args[0], "${CLAUDE_PLUGIN_ROOT}/scripts/wake");
    assert_eq!(args[1], "wake-mcp");
    let codex_market = json(repo.join(".agents/plugins/marketplace.json"));
    let codex_entry = &codex_market["plugins"][0];
    assert!(cli::CODEX_PLUGIN_INSTALL.ends_with(&install_id(&codex_market)));
    assert_eq!(
        codex_entry["source"]["path"], entry["source"],
        "同一个插件目录"
    );
    let codex_manifest = json(plugin.join(".codex-plugin/plugin.json"));
    assert_eq!(codex_manifest["name"], codex_entry["name"]);
    // Codex 按版本缓存装好的插件,版本不变就不重装:跟 Wake 一起走,发版改 Cargo.toml 时一并改
    assert_eq!(codex_manifest["version"], env!("CARGO_PKG_VERSION"));
    assert_eq!(
        codex_manifest["mcpServers"]["wake"],
        json!({
            "command": "sh",
            "args": ["./scripts/wake", "wake-mcp"],
            "cwd": ".",
            "env_vars": ["WAKE_BIN_DIR", ON_REQUEST_ENV]
        })
    );
    for field in ["logo", "composerIcon"] {
        let asset = codex_manifest["interface"][field].as_str().unwrap();
        assert!(plugin.join(asset).is_file(), "{field}: {asset}");
    }
    // 文档里的安装命令就是 Connect 页复制的那条
    for doc in ["README.md", "docs/cli.md", "docs/mcp.md"] {
        let text = std::fs::read_to_string(repo.join(doc)).unwrap();
        for command in [cli::CLAUDE_PLUGIN_INSTALL, cli::CODEX_PLUGIN_INSTALL] {
            assert!(
                text.contains(command),
                "{doc} 里的安装命令过时了: {command}"
            );
        }
    }

    let launcher = std::fs::read_to_string(plugin.join("scripts/wake")).unwrap();
    assert!(launcher.contains("/Applications/Wake.app/Contents/MacOS"));
    // tar 包装进 ~/.local/bin、deb 装进 /usr/bin
    let linux = std::fs::read_to_string(repo.join("scripts/make-linux.sh")).unwrap();
    for dir in ["$HOME/.local/bin", "/usr/bin"] {
        assert!(launcher.contains(dir), "启动脚本没找 {dir}");
        assert!(
            linux.contains(&format!("{dir}/wake-cli")),
            "Linux 打包不再落在 {dir}"
        );
    }
}