folderbase-cli 0.7.2

Folderbase command-line tools for agent-ready local-first folders.
use std::fs;

use assert_cmd::Command;
use predicates::prelude::*;

const FOLDERBASE_ID: &str = "folderbase_019f9b75-4f42-7f65-a012-2bfecdd8c473";
const MANIFEST_SHA256: &str = "29a1ad6f2d1c5591b35951a39bc38603728527f8be808510f080db1922c3f8be";
#[cfg(not(windows))]
const CURRENT_ROOT_INSTANCE_FORMAT: &str = "folderbase-physical-root-instance-v1";
#[cfg(windows)]
const CURRENT_ROOT_INSTANCE_FORMAT: &str = "folderbase-physical-root-instance-v2";
const MANIFEST: &[u8] = br#"{
  "protocol_version": "0.2.0+attestation",
  "folderbase": {
    "id": "folderbase_019f9b75-4f42-7f65-a012-2bfecdd8c473"
  }
}
"#;

fn folderbase() -> Command {
    Command::cargo_bin("folderbase").expect("folderbase executable")
}

fn valid_root() -> tempfile::TempDir {
    let root = tempfile::tempdir().expect("root");
    write_valid_root(root.path());
    root
}

fn write_valid_root(root: &std::path::Path) {
    fs::create_dir_all(root.join(".folderbase")).expect("state");
    fs::write(root.join(".folderbase/manifest.json"), MANIFEST).expect("manifest");
    fs::write(root.join("FOLDERBASE.md"), b"# Folderbase\n").expect("entry");
}

#[test]
fn attest_json_emits_the_flat_public_receipt() {
    let root = valid_root();
    let assertion = folderbase()
        .args([
            "attest",
            root.path().to_str().expect("UTF-8 root"),
            "--json",
        ])
        .assert()
        .success()
        .stderr(predicate::str::is_empty());

    let value: serde_json::Value =
        serde_json::from_slice(&assertion.get_output().stdout).expect("receipt JSON");
    let object = value.as_object().expect("flat JSON object");
    assert_eq!(object.len(), 5);
    assert_eq!(value["root"], root.path().to_string_lossy().as_ref());
    assert_eq!(value["folderbase_id"], FOLDERBASE_ID);
    assert_eq!(value["protocol_version"], "0.2.0+attestation");
    assert_eq!(value["manifest_sha256"], MANIFEST_SHA256);
    assert!(
        value["root_instance_sha256"]
            .as_str()
            .is_some_and(|digest| digest.len() == 64
                && digest
                    .bytes()
                    .all(|byte| byte.is_ascii_hexdigit() && !byte.is_ascii_uppercase()))
    );
}

#[test]
fn attest_human_output_names_the_same_evidence() {
    let root = valid_root();

    folderbase()
        .args(["attest", root.path().to_str().expect("UTF-8 root")])
        .assert()
        .success()
        .stderr(predicate::str::is_empty())
        .stdout(predicate::str::contains(format!(
            "Attested Folderbase root: {}",
            root.path().display()
        )))
        .stdout(predicate::str::contains(format!(
            "Folderbase ID: {FOLDERBASE_ID}"
        )))
        .stdout(predicate::str::contains(
            "Protocol version: 0.2.0+attestation",
        ))
        .stdout(predicate::str::contains(format!(
            "Manifest SHA-256: {MANIFEST_SHA256}"
        )))
        .stdout(predicate::str::contains(format!(
            "Physical root instance ({CURRENT_ROOT_INSTANCE_FORMAT}): "
        )));
}

#[test]
fn attest_json_failure_uses_the_stable_envelope_and_exit_two() {
    let ordinary_folder = tempfile::tempdir().expect("ordinary folder");
    let assertion = folderbase()
        .args([
            "attest",
            ordinary_folder.path().to_str().expect("UTF-8 root"),
            "--json",
        ])
        .assert()
        .code(2)
        .stdout(predicate::str::is_empty());

    let value: serde_json::Value =
        serde_json::from_slice(&assertion.get_output().stderr).expect("error JSON");
    assert_eq!(value["error"]["code"], "marker_missing");
    assert_eq!(
        value["error"]["message"],
        "required Folderbase marker is missing: .folderbase"
    );
}

#[cfg(target_os = "linux")]
#[test]
fn attest_json_uses_a_display_string_for_an_exact_non_utf8_root() {
    use std::{ffi::OsString, os::unix::ffi::OsStringExt};

    let parent = tempfile::tempdir().expect("parent");
    let non_utf8_name = OsString::from_vec(b"folderbase-\xff-root".to_vec());
    let root = parent.path().join(non_utf8_name);
    write_valid_root(&root);

    let assertion = folderbase()
        .arg("attest")
        .arg(&root)
        .arg("--json")
        .assert()
        .success()
        .stderr(predicate::str::is_empty());
    let value: serde_json::Value =
        serde_json::from_slice(&assertion.get_output().stdout).expect("flat receipt JSON");

    assert_eq!(value["root"], root.to_string_lossy().as_ref());
    assert_eq!(value["folderbase_id"], FOLDERBASE_ID);
    assert_eq!(value.as_object().expect("flat receipt").len(), 5);
}