Proposal clients: oxy seal --proposal, oxy proposal show|land, seal-only pushes, http_get for hub APIs d82e44097323

//! Thin clients of a hub's proposals (hub spec §7): `oxy proposal show`,

//! `oxy proposal land`, and `oxy seal --proposal`. The hub's JSON is read

//! by field name (hub-api `Proposal`); nothing here needs the hub crate.

use super::{open, ui};

use anyhow::{anyhow, Context, Result};

use oxy_core::hash::ChangeHash;

use oxy_core::repo::Repo;

use serde_json::Value;

/// `https://hub/{owner}/{name}/proposal/{n}` (or the API URL) to the API

/// URL and the repository's clone URL.

pub fn api_url(url: &str) -> Result<(String, String)> {

    let url = url.trim_end_matches('/');

    if url.contains("/api/v1/repos/") {

        let (base, rest) = url.split_once("/api/v1/repos/").unwrap();

        let mut parts = rest.split('/');

        let (owner, name) = (parts.next().unwrap_or(""), parts.next().unwrap_or(""));

        return Ok((url.to_string(), format!("{base}/{owner}/{name}")));

    }

    let (repo_url, number) = url.rsplit_once("/proposal/").ok_or_else(|| anyhow!("{url} is not a proposal URL (…/OWNER/NAME/proposal/N)"))?;

    let (base, slug) = repo_url.rsplit_once('/').and_then(|(b, n)| b.rsplit_once('/').map(|(bb, o)| (bb, format!("{o}/{n}")))).ok_or_else(|| anyhow!("{url} is not a proposal URL"))?;

    Ok((format!("{base}/api/v1/repos/{slug}/proposals/{number}"), repo_url.to_string()))

}

pub fn fetch(repo: &Repo, url: &str) -> Result<(Value, String)> {

    let (api, repo_url) = api_url(url)?;

    let options = repo.options_for_url(&repo_url);

    let body = oxy_core::protocol::http_get(&api, &options).map_err(|e| anyhow!("{e}"))?;

    let v: Value = serde_json::from_slice(&body).context("the hub did not answer with JSON")?;

    Ok((v, repo_url))

}

fn hashes(v: &Value, key: &str) -> Vec<ChangeHash> {

    v.get(key).and_then(Value::as_array).map(|a| a.iter().filter_map(|x| x.as_str().and_then(ChangeHash::from_hex)).collect()).unwrap_or_default()

}

fn change_hashes(v: &Value) -> Vec<ChangeHash> {

    v.get("changes").and_then(Value::as_array).map(|a| a.iter().filter_map(|c| c.get("hash").and_then(Value::as_str).and_then(ChangeHash::from_hex)).collect()).unwrap_or_default()

}

fn text<'a>(v: &'a Value, key: &str) -> &'a str {

    v.get(key).and_then(Value::as_str).unwrap_or("")

}

pub fn show(url: &str, as_json: bool) -> Result<i32> {

    let repo = open()?;

    let (v, _) = fetch(&repo, url)?;

    if as_json {

        println!("{v}");

        return Ok(0);

    }

    println!("{} #{} {}", ui::done("Proposal"), v.get("number").and_then(Value::as_i64).unwrap_or(0), ui::bookmark(text(&v, "title")));

    println!("{}", ui::kv("state", text(&v, "state")));

    println!("{}", ui::kv("target", ui::bookmark(text(&v, "target"))));

    println!("{}", ui::kv("author", ui::author(text(&v, "author"))));

    let changes = v.get("changes").and_then(Value::as_array).cloned().unwrap_or_default();

    println!("{}", ui::kv("changes", changes.len().to_string()));

    for c in &changes {

        println!("  {} {}", ui::hash(&text(c, "hash")[..12.min(text(c, "hash").len())]), text(c, "message").lines().next().unwrap_or(""));

    }

    if v.get("conflicted").and_then(Value::as_bool).unwrap_or(false) {

        println!("{}", ui::warn("landing would carry conflicts"));

    }

    if let Some(blockers) = v.get("blockers").and_then(Value::as_array) {

        for b in blockers {

            println!("  {} {}", ui::warn("blocked:"), b.as_str().unwrap_or(""));

        }

    }

    let approvals = v.get("approvals").and_then(Value::as_array).cloned().unwrap_or_default();

    for a in &approvals {

        let mark = if a.get("sealed").and_then(Value::as_bool).unwrap_or(false) { ui::done("approved") } else { ui::warn("pending seal") };

        println!("  {mark} {}", text(a, "account"));

    }

    Ok(0)

}

/// Seal every change of the proposal with your key and push the seal to

/// the hub, so your approval counts (hub spec §7.4).

pub fn seal(url: &str, as_json: bool) -> Result<i32> {

    let repo = open()?;

    let (v, repo_url) = fetch(&repo, url)?;

    let hashes = change_hashes(&v);

    if hashes.is_empty() {

        anyhow::bail!("the proposal has no changes to seal");

    }

    ensure_changes(&repo, &repo_url, &hashes, &hashes)?;

    let mut refs = Vec::new();

    for chunk in hashes.chunks(oxy_core::attest::MAX_SEAL_HASHES) {

        refs.push(repo.seal(chunk)?);

    }

    let remote = repo.remote_for_url(&repo_url).ok_or_else(|| anyhow!("no remote is configured for {repo_url}; add one with `oxy remote add`"))?;

    repo.push_seals(&remote, &refs)?;

    if as_json {

        let list: Vec<String> = hashes.iter().map(|h| format!("\"{}\"", h.to_hex())).collect();

        println!("{{\"sealed\":[{}],\"pushed\":true}}", list.join(","));

    } else {

        println!("{} {} change{} of the proposal and pushed the seal to {remote}", ui::done("Sealed"), hashes.len(), if hashes.len() == 1 { "" } else { "s" });

    }

    Ok(0)

}

/// Fetch the proposal's changes (and anything they need) from the hub

/// into the local store.

fn ensure_changes(repo: &Repo, repo_url: &str, want: &[ChangeHash], _changes: &[ChangeHash]) -> Result<()> {

    let missing: Vec<ChangeHash> = want.iter().copied().filter(|h| !repo.store().has(h)).collect();

    if missing.is_empty() {

        return Ok(());

    }

    let (_, remote) = repo.open_remote_at(repo_url)?;

    let view = repo.view()?;

    let have = repo.known_heads(&view)?;

    let needed = remote.negotiate(&have, want)?;

    let bundle = remote.fetch(&needed, repo.config.max_blob)?;

    repo.import_bundle(&bundle, false)?;

    Ok(())

}

/// Land the proposal from this client: fetch its changes, set the target

/// bookmark to the projected heads, and push with your own key (hub spec

/// §7.6).

pub fn land(url: &str, force: bool) -> Result<i32> {

    let repo = open()?;

    let (v, repo_url) = fetch(&repo, url)?;

    let state = text(&v, "state");

    if state != "open" && !force {

        anyhow::bail!("the proposal is {state}, not open (use --force to land anyway)");

    }

    if !v.get("landable").and_then(Value::as_bool).unwrap_or(false) && !force {

        let blockers: Vec<String> = v.get("blockers").and_then(Value::as_array).map(|a| a.iter().filter_map(|b| b.as_str().map(String::from)).collect()).unwrap_or_default();

        anyhow::bail!("the hub says the proposal cannot land yet: {} (use --force to land anyway)", blockers.join("; "));

    }

    let target = text(&v, "target").to_string();

    let heads = hashes(&v, "projected_heads");

    if heads.is_empty() {

        anyhow::bail!("the hub has not computed the projected state yet; try again shortly");

    }

    ensure_changes(&repo, &repo_url, &heads, &change_hashes(&v))?;

    let remote = repo.remote_for_url(&repo_url).ok_or_else(|| anyhow!("no remote is configured for {repo_url}; add one with `oxy remote add`"))?;

    // Bring the target bookmark up to date first, so the push is a fast-forward.

    repo.fetch(&remote)?;

    repo.bookmark_set(&target, &heads)?;

    let results = repo.push_bookmark(&remote, &target, false)?;

    for r in &results {

        if r.ok {

            println!("{} {}/{} - landed proposal", ui::done("Pushed"), remote, r.name);

        } else {

            println!("{} {}/{} - {}", ui::warn("Rejected"), remote, r.name, r.reason);

        }

    }

    Ok(if results.iter().all(|r| r.ok) { 0 } else { 1 })

}

serde_json = "1"

/// An authenticated GET of any URL on a host, with the same TLS trust and

/// token as remotes use (for hub APIs: proposals). Returns the body.

pub fn http_get(url: &str, options: &RemoteOptions) -> Result<Vec<u8>> {

    let agent = ureq::AgentBuilder::new()

        .tls_config(tls_client_config(options.ca.as_deref())?)

        .build();

    let mut req = agent.get(url).set("Accept", "application/json");

    if let Some(t) = &options.token {

        req = req.set("Authorization", &format!("Bearer {t}"));

    }

    match req.call() {

        Ok(r) => {

            let mut out = Vec::new();

            r.into_reader()

                .read_to_end(&mut out)

                .map_err(|e| RepoError::Msg(format!("{url}: {e}")))?;

            Ok(out)

        }

        Err(ureq::Error::Status(code, r)) => {

            let text = r.into_string().unwrap_or_default();

            Err(RepoError::Msg(format!("{url}: HTTP {code}: {}", text.trim())))

        }

        Err(e) => Err(RepoError::Msg(format!("{url}: {e}"))),

    }

}

    /// Push seal attestations on their own (hub spec §7.4): a bundle with

    /// no changes and no reference updates, which the receiver stores.

    pub fn push_seals(&self, remote_name: &str, seals: &[ObjectRef]) -> Result<()> {

        let remote = self.open_named_remote(remote_name)?;

        self.check_remote_id(remote.as_ref(), remote_name, false)?;

        let mut bundle = Bundle::default();

        for r in seals {

            let attest = self.store.get_attest(r)?;

            let sigs = self.store.signatures(r)?;

            bundle.attests.push(crate::protocol::SignedAttest { attest, sigs });

        }

        let results = remote.push(bundle, vec![], None, vec![])?;

        if let Some(r) = results.iter().find(|r| !r.ok) {

            return fail(format!("{}: {}", r.name, r.reason));

        }

        Ok(())

    }

    /// The remote whose URL starts with `base` (a hub), if configured.

    pub fn remote_for_url(&self, base: &str) -> Option<String> {

        let base = base.trim_end_matches('/');

        self.config.remotes.iter().find(|(_, url)| url.trim_end_matches('/') == base).map(|(name, _)| name.clone())

    }

    /// Open a remote by name or, failing that, by URL with the default

    /// credentials (`OXY_TOKEN`, `OXY_CA`).

    pub fn open_remote_at(&self, url: &str) -> Result<(String, Box<dyn crate::protocol::Remote>)> {

        if let Some(name) = self.remote_for_url(url) {

            return Ok((name.clone(), self.open_named_remote(&name)?));

        }

        let options = RemoteOptions {

            token: std::env::var("OXY_TOKEN").ok(),

            ca: std::env::var("OXY_CA").ok().map(PathBuf::from),

            repo_id: self.id().ok(),

        };

        Ok((url.to_string(), open_remote(url, &options)?))

    }

    /// Credentials for a URL: those of the configured remote with that

    /// URL, else the environment's.

    pub fn options_for_url(&self, url: &str) -> RemoteOptions {

        match self.remote_for_url(url) {

            Some(name) => self.remote_options(&name),

            None => RemoteOptions {

                token: std::env::var("OXY_TOKEN").ok(),

                ca: std::env::var("OXY_CA").ok().map(PathBuf::from),

                repo_id: self.id().ok(),

            },

        }

    }

    pub fn known_heads(&self, view: &View) -> Result<Vec<ChangeHash>> {

oxy seal [CHANGE].. | --proposal URL  seal your unauthenticated and anonymous changes (§14.4), or a hub proposal's changes as your approval

oxy proposal show|land URL          hub proposals from a client (hub spec §7)

mod proposal;

        /// Seal every change of a hub proposal and push the seal (your approval)

        #[arg(long, conflicts_with = "changes")]

        proposal: Option<String>,

    /// Hub proposals: show one, or land it from this client

    Proposal {

        #[command(subcommand)]

        cmd: ProposalCmd,

    },

enum ProposalCmd {

    /// Show a proposal by its hub URL

    Show {

        url: String,

        #[arg(long)]

        json: bool,

    },

    /// Fetch the proposal's changes, set the target bookmark to the projected state, and push with your key

    Land {

        url: String,

        /// Land even when the hub reports blockers

        #[arg(long)]

        force: bool,

    },

}

#[derive(Subcommand)]

        Cmd::Seal { changes, proposal: Some(url), json } if changes.is_empty() => proposal::seal(&url, json),

        Cmd::Seal { changes, json, .. } => identity::seal(&changes, json),

        Cmd::Proposal { cmd } => match cmd {

            ProposalCmd::Show { url, json } => proposal::show(&url, json),

            ProposalCmd::Land { url, force } => proposal::land(&url, force),

        },