Coverage / src/cli/identity.rs 54.8%

pub fn owner_home(ctx: &Ctx, flag: Option<PathBuf>) -> PathBuf {

    flag.or_else(|| ctx.config_owner_home()).unwrap_or_else(oxy_core::repo::default_home)

}

pub async fn init(ctx: &Ctx, owner_home_flag: Option<PathBuf>, name: Option<String>) -> Result<i32> {

    let data = &ctx.data;

    let db = data.join("spectra.db");

    if db.exists() {

        bail!("{} already holds a Spectra (spectra identity show)", data.display());

    }

    let home = owner_home(ctx, owner_home_flag);

    let owner = KeyPair::load_home(&home).with_context(|| {

        format!("the owner signs with their own identity: none usable in {} (oxy identity create, or --owner-home)", home.display())

    })?;

    std::fs::create_dir_all(data)?;

        std::fs::set_permissions(data, std::fs::Permissions::from_mode(0o700))?;

    let name = name.unwrap_or_else(hostname);

    let instance = KeyPair::instance(data, &name)?;

    let ledger = Ledger::open(&db, Some(instance.clone())).await?;

    let mut first = vec![

        signed_event(&owner, "human", "identity.owner", identity_payload(&owner.identity)),

        signed_event(&instance, "system", "identity.instance", identity_payload(&instance.identity)),

    first.extend(spectra_core::conversation::default_channel_events());

    ledger.append(first).await?;

    ledger.checkpoint().await?;

    let home_s = home.display().to_string();

    std::fs::write(

        data.join("spectra.toml"),

        format!("# Spectra's configuration (spec §22.1).\n\n[owner]\nkey = \"{}\"\nhome = {}\n", owner.key.to_hex(), toml_str(&home_s)),

    println!("{} {}  {}", ui::done("Initialised"), ui::subject("Spectra"), ui::path(data.display()));

    println!("{}", ui::kv("owner", format!("{}{}{}", ui::author(&owner.identity.name), ui::sep(), ui::hash(owner.key.short(12)))));

    println!("{}", ui::kv("instance", format!("{}{}{}", name, ui::sep(), ui::hash(instance.key.short(12)))));

    println!("{}", ui::kv("ledger", format!("{}{}", ui::path(db.display()), ui::dim(" (verified with spectra admin verify)"))));

    println!();

    println!("  {} {}", ui::note(), ui::dim("so that checkpoints are verifiably from your machine, delegate to the instance key:"));

    println!(

        ui::id(format!("oxy identity delegate add {} --scope changes", data.join("keys").join("instance.identity").display()))

    println!(

        ui::note(),

        ui::dim("then add agents with"),

        ui::id("spectra agent add NAME --kind KIND --project PROJECT --home DIR")

    Ok(0)

}

pub async fn refresh_event(ledger: &Ledger, home: &Path) -> Result<Option<spectra_core::event::NewEvent>> {

    let p = Principals::load(ledger).await?;

    let recorded = p.owner().context("no owner is recorded (spectra init)")?.clone();

    let pair = KeyPair::load_home(home)?;

    if pair.key == recorded.hash() {

        return Ok(None);

    }

    let mut chain = Vec::new();

    let mut at = pair.identity.clone();

    while let Some(prev) = at.previous {

        if prev == recorded.hash() {

            break;

    if at.previous != Some(recorded.hash()) && pair.identity.previous != Some(recorded.hash()) {

    }

    let mut payload = identity_payload(&pair.identity);

    payload["chain"] = chain.into();

    Ok(Some(signed_event(&pair, "human", "identity.rotated", payload)))

}

pub async fn recorded_owner(ledger: &Ledger, home: &Path) -> Result<KeyPair> {

    let p = Principals::load(ledger).await?;

    let recorded = p.owner().context("no owner is recorded (spectra init)")?.hash();

    let keys = home.join("keys");

    KeyPair::load(&keys.join(format!("{}.secret", recorded.to_hex())), &keys.join(format!("{}.identity", recorded.to_hex())))

        .with_context(|| format!("the recorded owner's key is not in {}", home.display()))

}

fn hostname() -> String {

    std::fs::read_to_string("/etc/hostname")

        .ok()

        .map(|h| h.trim().to_string())

        .filter(|h| !h.is_empty())

        .unwrap_or_else(|| "spectra".into())

}

fn toml_str(s: &str) -> String {

    serde_json::to_string(s).unwrap_or_default()

}