oh: OxygenHub from the command line 5c6e92fd8d71

[package]

name = "oh"

description = "OxygenHub from the command line: issues, proposals, Flow runs and releases"

version.workspace = true

edition.workspace = true

license.workspace = true

authors.workspace = true

[[bin]]

name = "oh"

path = "src/main.rs"

[dependencies]

hub-api = { path = "../hub-api" }

oxy-core.workspace = true

clap.workspace = true

serde.workspace = true

serde_json.workspace = true

toml.workspace = true

ureq = "2"

anyhow.workspace = true

[dev-dependencies]

oxygenhub = { path = "../hub" }

tokio.workspace = true

tempfile.workspace = true

axum.workspace = true

//! The hub's JSON API over HTTPS, with the checkout's CA when the hub's

//! certificate is self-signed.

use crate::target::Target;

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

use serde::de::DeserializeOwned;

use serde::Serialize;

use std::time::Duration;

pub struct Client {

    agent: ureq::Agent,

    base: String,

    token: Option<String>,

}

impl Client {

    pub fn new(t: &Target) -> Result<Client> {

        let tls = oxy_core::protocol::tls_client_config(t.ca.as_deref()).map_err(|e| anyhow::anyhow!("{e}"))?;

        let agent = ureq::AgentBuilder::new().tls_config(tls).timeout(Duration::from_secs(120)).build();

        Ok(Client { agent, base: format!("{}/api/v1", t.hub), token: t.token.clone() })

    }

    fn req(&self, method: &str, path: &str) -> ureq::Request {

        let r = self.agent.request(method, &format!("{}{path}", self.base)).set("Accept", "application/json");

        match &self.token {

            Some(t) => r.set("Authorization", &format!("Bearer {t}")),

            None => r,

        }

    }

    fn finish(res: Result<ureq::Response, ureq::Error>, what: &str) -> Result<String> {

        match res {

            Ok(r) => Ok(r.into_string()?),

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

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

                // Problem documents (RFC 7807) carry the reason in `detail`.

                let detail = serde_json::from_str::<serde_json::Value>(&body)

                    .ok()

                    .and_then(|v| v["detail"].as_str().map(String::from))

                    .unwrap_or(body);

                let hint = match code {

                    401 => " (sign in: `oh auth login`, or push with a token first)",

                    403 => " (your token lacks the scope or the role for this)",

                    _ => "",

                };

                bail!("{what}: HTTP {code}: {}{hint}", detail.trim())

            }

            Err(e) => Err(e).context(what.to_string()),

        }

    }

    /// GET, as raw JSON text.

    pub fn get_text(&self, path: &str) -> Result<String> {

        Self::finish(self.req("GET", path).call(), &format!("GET {path}"))

    }

    pub fn get<T: DeserializeOwned>(&self, path: &str) -> Result<T> {

        let text = self.get_text(path)?;

        serde_json::from_str(&text).with_context(|| format!("GET {path}: unexpected answer"))

    }

    pub fn send_text(&self, method: &str, path: &str, body: &impl Serialize) -> Result<String> {

        let json = serde_json::to_string(body)?;

        Self::finish(self.req(method, path).set("Content-Type", "application/json").send_string(&json), &format!("{method} {path}"))

    }

    pub fn send<T: DeserializeOwned>(&self, method: &str, path: &str, body: &impl Serialize) -> Result<T> {

        let text = self.send_text(method, path, body)?;

        serde_json::from_str(&text).with_context(|| format!("{method} {path}: unexpected answer"))

    }

    /// POST raw bytes (a release asset).

    pub fn upload(&self, path: &str, bytes: &[u8]) -> Result<String> {

        Self::finish(

            self.req("POST", path).set("Content-Type", "application/octet-stream").timeout(Duration::from_secs(1800)).send_bytes(bytes),

            &format!("POST {path}"),

        )

    }

}

//! `oh`: OxygenHub from the command line, as `gh` is for GitHub. It talks

//! to the hub's JSON API (hub spec §12) as the checkout's remote does:

//! same hub, same token, same CA.

mod client;

mod target;

mod ui;

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

use clap::{Parser, Subcommand};

use client::Client;

use hub_api::{FlowLogLine, FlowRun, Issue, IssueStateChange, NewComment, NewIssue, NewProposal, NewRelease, Proposal, Release};

use std::time::Duration;

use target::{Choice, Config, Host, Target};

#[derive(Parser)]

#[command(name = "oh", version, about = "OxygenHub from the command line: issues, proposals, Flow runs and releases")]

struct Cli {

    /// The repository, when not inside an Oxygen checkout

    #[arg(long, short = 'R', global = true, value_name = "OWNER/NAME")]

    repo: Option<String>,

    /// The hub, with --repo or outside a checkout (default: OH_HUB or the one `oh auth login` saved)

    #[arg(long, global = true, value_name = "URL")]

    hub: Option<String>,

    /// Which of the checkout's remotes to use (default: origin, or the only one)

    #[arg(long, global = true)]

    remote: Option<String>,

    /// Machine-readable output: the API's JSON, unchanged

    #[arg(long, global = true)]

    json: bool,

    /// Plain output: no colour or glyphs (also NO_COLOR, or when not a terminal)

    #[arg(long, global = true)]

    plain: bool,

    #[command(subcommand)]

    cmd: Cmd,

}

#[derive(Subcommand)]

enum Cmd {

    /// Sign in to a hub, or show who you are signed in as

    Auth {

        #[command(subcommand)]

        cmd: AuthCmd,

    },

    /// The repository

    Repo {

        #[command(subcommand)]

        cmd: RepoCmd,

    },

    /// Issues

    Issue {

        #[command(subcommand)]

        cmd: IssueCmd,

    },

    /// Proposals (pull requests)

    Proposal {

        #[command(subcommand)]

        cmd: ProposalCmd,

    },

    /// OxygenFlow runs

    Run {

        #[command(subcommand)]

        cmd: RunCmd,

    },

    /// Releases

    Release {

        #[command(subcommand)]

        cmd: ReleaseCmd,

    },

    /// Call the API directly: `oh api /repos/OWNER/NAME/issues`

    Api {

        /// A path under /api/v1

        path: String,

        /// The method

        #[arg(long, short = 'X', default_value = "GET")]

        method: String,

        /// A JSON body

        #[arg(long, short = 'd')]

        data: Option<String>,

    },

}

#[derive(Subcommand)]

enum AuthCmd {

    /// Save a token for a hub (read from stdin when not given) and make it the default

    Login {

        /// The hub, e.g. https://earth.example:7343

        #[arg(long = "with-hub", value_name = "URL")]

        url: String,

        /// An API token from the hub's Settings → Tokens

        #[arg(long)]

        token: Option<String>,

        /// The hub's CA certificate, when self-signed

        #[arg(long)]

        ca: Option<std::path::PathBuf>,

    },

    /// Who the token in use belongs to

    Status,

}

#[derive(Subcommand)]

enum RepoCmd {

    /// Name, description, visibility and default bookmark

    View,

}

#[derive(Subcommand)]

enum IssueCmd {

    /// Open issues (or --state closed|all)

    List {

        #[arg(long, default_value = "open")]

        state: String,

    },

    /// One issue with its comments

    View { number: i64 },

    /// Open an issue

    Create {

        #[arg(long, short)]

        title: String,

        #[arg(long, short)]

        body: Option<String>,

        /// Read the body from a file ("-" for stdin)

        #[arg(long, short = 'F')]

        body_file: Option<String>,

        /// A label (repeatable)

        #[arg(long, short)]

        label: Vec<String>,

    },

    /// Close an issue

    Close {

        number: i64,

        /// `completed` or `not_planned`

        #[arg(long, default_value = "completed")]

        reason: String,

    },

    /// Reopen an issue

    Reopen { number: i64 },

    /// Comment on an issue

    Comment {

        number: i64,

        #[arg(long, short)]

        body: String,

    },

}

#[derive(Subcommand)]

enum ProposalCmd {

    /// Open proposals

    List,

    /// One proposal: its changes, approvals and whether it can land

    View { number: i64 },

    /// Propose a bookmark's changes for another bookmark

    Create {

        #[arg(long, short)]

        title: String,

        #[arg(long, short)]

        body: Option<String>,

        /// The bookmark with the changes (or OWNER/NAME:BOOKMARK of a fork)

        #[arg(long)]

        from: String,

        /// The bookmark to land them on (default: the repository's default bookmark)

        #[arg(long)]

        into: Option<String>,

        #[arg(long)]

        draft: bool,

    },

    /// The checks on a proposal's projected state

    Checks { number: i64 },

}

#[derive(Subcommand)]

enum RunCmd {

    /// Recent runs, newest first

    List {

        #[arg(long, default_value_t = 20)]

        limit: i64,

    },

    /// A run and its jobs

    View { number: i64 },

    /// Run the pipeline without a push: a bookmark's current state (default: the default bookmark), or one change's

    Start {

        #[arg(long)]

        bookmark: Option<String>,

        /// A change's full hash

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

        change: Option<String>,

        /// Wait for the run and exit 1 unless it passes

        #[arg(long)]

        watch: bool,

    },

    /// Follow a run until it finishes; exit 1 unless it passes

    Watch { number: i64 },

    /// A job's log

    Log { number: i64, job: String },

    /// Run a finished run's state again

    Rerun { number: i64 },

}

#[derive(Subcommand)]

enum ReleaseCmd {

    /// Releases, newest first

    List,

    /// Create a release on an existing tag

    Create {

        tag: String,

        #[arg(long, short)]

        title: Option<String>,

        /// Notes in Markdown (default: generated from the changes since the previous release)

        #[arg(long, short)]

        notes: Option<String>,

        #[arg(long)]

        prerelease: bool,

    },

    /// Attach files to a release

    Upload { tag: String, files: Vec<std::path::PathBuf> },

    /// The release's trust report: signatures, builds, receipts and audit

    Trust { tag: String },

}

fn main() {

    let cli = Cli::parse();

    ui::init(cli.plain);

    match run(cli) {

        Ok(code) => std::process::exit(code),

        Err(e) => {

            eprintln!("{} {e:#}", ui::bad("error:"));

            std::process::exit(2);

        }

    }

}

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

    let mut out = String::new();

    for b in s.bytes() {

        if b.is_ascii_alphanumeric() || b"-._~".contains(&b) {

            out.push(b as char);

        } else {

            out.push_str(&format!("%{b:02X}"));

        }

    }

    out

}

fn run(cli: Cli) -> Result<i32> {

    let cfg = Config::load()?;

    if let Cmd::Auth { cmd: AuthCmd::Login { url, token, ca } } = &cli.cmd {

        return login(cfg, url, token.clone(), ca.clone());

    }

    let here = std::env::current_dir()?;

    let t = target::resolve(&Choice { repo: cli.repo.as_deref(), hub: cli.hub.as_deref(), remote: cli.remote.as_deref() }, &here, &cfg)?;

    let c = Client::new(&t)?;

    let json = cli.json;

    match cli.cmd {

        Cmd::Auth { cmd: AuthCmd::Status } => {

            let me: serde_json::Value = c.get("/user")?;

            if json {

                println!("{me}");

            } else {

                println!("{} signed in to {} as {}", ui::ok("✔"), t.hub, ui::strong(me["username"].as_str().unwrap_or("?")));

            }

            Ok(0)

        }

        Cmd::Auth { .. } => unreachable!(),

        Cmd::Api { path, method, data } => {

            let path = if path.starts_with('/') { path } else { format!("/{path}") };

            let text = match data {

                Some(d) => c.send_text(

                    &method.to_uppercase(),

                    &path,

                    &serde_json::from_str::<serde_json::Value>(&d).context("--data is not JSON")?,

                )?,

                None => c.get_text(&path)?,

            };

            println!("{text}");

            Ok(0)

        }

        Cmd::Repo { cmd: RepoCmd::View } => {

            let path = t.repo_path()?;

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let r: serde_json::Value = c.get(&path)?;

            println!("{} {}", ui::strong(&format!("{}/{}", t.owner, t.name)), ui::dim(r["visibility"].as_str().unwrap_or("")));

            if let Some(d) = r["description"].as_str().filter(|d| !d.is_empty()) {

                println!("{d}");

            }

            println!("{}", ui::kv("default bookmark", r["default_bookmark"].as_str().unwrap_or("")));

            println!("{}", ui::kv("clone", &format!("oxy clone {}/{}/{}", t.hub, t.owner, t.name)));

            Ok(0)

        }

        Cmd::Issue { cmd } => issue(&c, &t, cmd, json),

        Cmd::Proposal { cmd } => proposal(&c, &t, cmd, json),

        Cmd::Run { cmd } => flow(&c, &t, cmd, json),

        Cmd::Release { cmd } => release(&c, &t, cmd, json),

    }

}

fn login(mut cfg: Config, url: &str, token: Option<String>, ca: Option<std::path::PathBuf>) -> Result<i32> {

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

    let token = match token {

        Some(t) => t,

        None => {

            eprintln!("Paste a token from {hub}/settings/tokens, then press Enter:");

            let mut line = String::new();

            std::io::stdin().read_line(&mut line)?;

            line.trim().to_string()

        }

    };

    if token.is_empty() {

        bail!("no token given");

    }

    let t = Target { hub: hub.clone(), token: Some(token.clone()), ca: ca.clone(), owner: String::new(), name: String::new() };

    let me: serde_json::Value = Client::new(&t)?.get("/user").context("checking the token")?;

    cfg.hosts.insert(hub.clone(), Host { token, ca });

    cfg.default_hub = Some(hub.clone());

    cfg.save()?;

    println!("{} signed in to {hub} as {}", ui::ok("✔"), ui::strong(me["username"].as_str().unwrap_or("?")));

    Ok(0)

}

fn body_of(body: Option<String>, file: Option<String>) -> Result<String> {

    match (body, file) {

        (Some(b), _) => Ok(b),

        (None, Some(f)) if f == "-" => {

            let mut s = String::new();

            std::io::Read::read_to_string(&mut std::io::stdin(), &mut s)?;

            Ok(s)

        }

        (None, Some(f)) => std::fs::read_to_string(&f).with_context(|| format!("read {f}")),

        (None, None) => Ok(String::new()),

    }

}

fn issue_line(i: &Issue) -> String {

    let glyph = if i.state == "open" { ui::ok("●") } else { ui::dim("○") };

    let labels: Vec<String> = i.labels.iter().map(|l| format!("[{}]", l.name)).collect();

    format!(

        "{glyph} {} {}{}{}",

        ui::dim(&format!("#{}", i.number)),

        i.title,

        if labels.is_empty() { String::new() } else { format!(" {}", ui::dim(&labels.join(" "))) },

        ui::dim(&format!(" · {} · {}", i.author, ui::ago(i.updated_ms)))

    )

}

fn issue(c: &Client, t: &Target, cmd: IssueCmd, json: bool) -> Result<i32> {

    let base = t.repo_path()?;

    match cmd {

        IssueCmd::List { state } => {

            let path = format!("{base}/issues?state={}", enc(&state));

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let list: Vec<Issue> = c.get(&path)?;

            if list.is_empty() {

                println!("{}", ui::dim(&format!("No {state} issues.")));

            }

            for i in &list {

                println!("{}", issue_line(i));

            }

        }

        IssueCmd::View { number } => {

            let path = format!("{base}/issues/{number}");

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let i: Issue = c.get(&path)?;

            println!("{}", issue_line(&i));

            if !i.body.trim().is_empty() {

                println!("\n{}\n", i.body.trim_end());

            }

            let comments: Vec<hub_api::Comment> = c.get(&format!("{path}/comments"))?;

            for cm in comments {

                println!("{} {}\n{}\n", ui::strong(&cm.author), ui::dim(&ui::ago(cm.created_ms)), cm.body.trim_end());

            }

            println!("{}", ui::dim(&i.url));

        }

        IssueCmd::Create { title, body, body_file, label } => {

            let new = NewIssue { title, body: body_of(body, body_file)?, labels: label, assignees: vec![], milestone: None };

            let i: Issue = c.send("POST", &format!("{base}/issues"), &new)?;

            if json {

                println!("{}", serde_json::to_string(&i)?);

            } else {

                println!("{} opened #{} {}", ui::ok("✔"), i.number, ui::dim(&i.url));

            }

        }

        IssueCmd::Close { number, reason } => {

            let i: Issue = c.send("POST", &format!("{base}/issues/{number}"), &IssueStateChange { state: "closed".into(), reason })?;

            println!("{} closed #{} {}", ui::ok("✔"), i.number, i.title);

        }

        IssueCmd::Reopen { number } => {

            let i: Issue =

                c.send("POST", &format!("{base}/issues/{number}"), &IssueStateChange { state: "open".into(), reason: String::new() })?;

            println!("{} reopened #{} {}", ui::ok("✔"), i.number, i.title);

        }

        IssueCmd::Comment { number, body } => {

            c.send_text("POST", &format!("{base}/issues/{number}/comments"), &NewComment { body, path: None, line: None })?;

            println!("{} commented on #{number}", ui::ok("✔"));

        }

    }

    Ok(0)

}

fn source_name(s: &hub_api::ProposalSource) -> String {

    match s {

        hub_api::ProposalSource::Bookmark { bookmark } => bookmark.clone(),

        hub_api::ProposalSource::Fork { owner, name, bookmark } => format!("{owner}/{name}:{bookmark}"),

        hub_api::ProposalSource::Changes { hashes } => format!("{} changes", hashes.len()),

    }

}

fn proposal_line(p: &Proposal) -> String {

    let state = serde_json::to_value(p.state).ok().and_then(|v| v.as_str().map(String::from)).unwrap_or_default();

    let glyph = match state.as_str() {

        "open" => ui::ok("●"),

        "draft" => ui::dim("◌"),

        "landed" => ui::strong("✔"),

        _ => ui::dim("○"),

    };

    format!(

        "{glyph} {} {} {}{}",

        ui::dim(&format!("#{}", p.number)),

        p.title,

        ui::dim(&format!("{} → {}", source_name(&p.source), p.target)),

        ui::dim(&format!(" · {} · {state}", p.author))

    )

}

fn proposal(c: &Client, t: &Target, cmd: ProposalCmd, json: bool) -> Result<i32> {

    let base = t.repo_path()?;

    match cmd {

        ProposalCmd::List => {

            let path = format!("{base}/proposals");

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let list: Vec<Proposal> = c.get(&path)?;

            if list.is_empty() {

                println!("{}", ui::dim("No open proposals."));

            }

            for p in &list {

                println!("{}", proposal_line(p));

            }

        }

        ProposalCmd::View { number } => {

            let path = format!("{base}/proposals/{number}");

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let p: Proposal = c.get(&path)?;

            println!("{}", proposal_line(&p));

            if !p.body.trim().is_empty() {

                println!("\n{}\n", p.body.trim_end());

            }

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

            for ch in &p.changes {

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

            }

            println!("{}", ui::kv("approvals", &p.approvals.iter().map(|a| a.account.clone()).collect::<Vec<_>>().join(", ")));

            if p.landable {

                println!("{} can land", ui::ok("✔"));

            } else {

                for b in &p.blockers {

                    println!("{} {b}", ui::bad("✘"));

                }

            }

            if p.conflicted {

                println!("{} landing it would leave conflicts", ui::bad("!"));

            }

            println!("{}", ui::dim(&p.url));

        }

        ProposalCmd::Create { title, body, from, into, draft } => {

            let target = match into {

                Some(i) => i,

                None => c.get::<serde_json::Value>(&base)?["default_bookmark"].as_str().unwrap_or("main").to_string(),

            };

            let new = NewProposal { title, body: body.unwrap_or_default(), target, source: from, draft };

            let p: Proposal = c.send("POST", &format!("{base}/proposals"), &new)?;

            if json {

                println!("{}", serde_json::to_string(&p)?);

            } else {

                println!("{} proposed #{} {}", ui::ok("✔"), p.number, ui::dim(&p.url));

            }

        }

        ProposalCmd::Checks { number } => {

            let path = format!("{base}/proposals/{number}/checks");

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let checks: Vec<hub_api::Check> = c.get(&path)?;

            if checks.is_empty() {

                println!("{}", ui::dim("No checks yet."));

            }

            for ch in checks {

                println!("{} {} {}", ui::status(ch.status.as_str()), ch.name, ui::dim(&ch.summary));

            }

        }

    }

    Ok(0)

}

fn run_line(r: &FlowRun) -> String {

    let what =

        if r.bookmark.is_empty() { format!("change {}", r.heads.first().map(|h| &h[..12]).unwrap_or("")) } else { r.bookmark.clone() };

    format!(

        "{} {} {} {}",

        ui::status(&r.status),

        ui::dim(&format!("#{}", r.number)),

        what,

        ui::dim(&format!("· {} by {} · {}", r.trigger, r.actor, ui::ago(r.created_ms)))

    )

}

fn print_run(r: &FlowRun) {

    println!("{}", run_line(r));

    for j in &r.jobs {

        let dur = match (j.started_ms, j.finished_ms) {

            (Some(a), Some(b)) => format!(" {:.1} s", (b - a) as f64 / 1000.0),

            _ => String::new(),

        };

        let on = if j.runner.is_empty() { String::new() } else { format!(" on {}", j.runner) };

        println!("  {} {}{}", ui::status(&j.status), j.name, ui::dim(&format!("{dur}{on}")));

    }

    if !r.error.is_empty() {

        println!("{}", ui::bad(&r.error));

    }

    println!("{}", ui::dim(&r.url));

}

fn live(status: &str) -> bool {

    matches!(status, "queued" | "running")

}

fn watch(c: &Client, base: &str, number: i64, json: bool) -> Result<i32> {

    let path = format!("{base}/flow/runs/{number}");

    let mut seen: std::collections::HashMap<String, String> = std::collections::HashMap::new();

    loop {

        let r: FlowRun = c.get(&path)?;

        if !json {

            for j in &r.jobs {

                if seen.get(&j.name) != Some(&j.status) {

                    println!("{} {}", ui::status(&j.status), j.name);

                    seen.insert(j.name.clone(), j.status.clone());

                }

            }

        }

        if !live(&r.status) {

            if json {

                println!("{}", serde_json::to_string(&r)?);

            } else {

                println!("{} run #{} {}", ui::status(&r.status), r.number, r.status);

            }

            return Ok(if r.status == "passed" { 0 } else { 1 });

        }

        std::thread::sleep(Duration::from_secs(3));

    }

}

fn flow(c: &Client, t: &Target, cmd: RunCmd, json: bool) -> Result<i32> {

    let base = t.repo_path()?;

    match cmd {

        RunCmd::List { limit } => {

            let path = format!("{base}/flow/runs?limit={limit}");

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let runs: Vec<FlowRun> = c.get(&path)?;

            if runs.is_empty() {

                println!("{}", ui::dim("No runs yet."));

            }

            for r in &runs {

                println!("{}", run_line(r));

            }

        }

        RunCmd::View { number } => {

            let path = format!("{base}/flow/runs/{number}");

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            print_run(&c.get(&path)?);

        }

        RunCmd::Start { bookmark, change, watch: follow } => {

            let body = match (bookmark, change) {

                (_, Some(ch)) => serde_json::json!({ "change": ch }),

                (Some(b), None) => serde_json::json!({ "bookmark": b }),

                (None, None) => serde_json::json!({}),

            };

            let started: serde_json::Value = c.send("POST", &format!("{base}/flow/runs"), &body)?;

            let n = started["number"].as_i64().context("the hub named no run")?;

            if !json || !follow {

                if json {

                    println!("{started}");

                } else {

                    println!("{} started run #{n} {}", ui::ok("✔"), ui::dim(started["url"].as_str().unwrap_or("")));

                }

            }

            if follow {

                return watch(c, &base, n, json);

            }

        }

        RunCmd::Watch { number } => return watch(c, &base, number, json),

        RunCmd::Log { number, job } => {

            let mut after = 0;

            loop {

                let path = format!("{base}/flow/runs/{number}/jobs/{}/log?after={after}&limit=5000", enc(&job));

                let lines: Vec<FlowLogLine> = c.get(&path)?;

                if lines.is_empty() {

                    break;

                }

                for l in &lines {

                    if json {

                        println!("{}", serde_json::to_string(l)?);

                    } else if l.stream == "flow" {

                        println!("{}", ui::dim(&l.text));

                    } else {

                        println!("{}", l.text);

                    }

                }

                after = lines.last().map(|l| l.seq).unwrap_or(after);

            }

        }

        RunCmd::Rerun { number } => {

            let started: serde_json::Value = c.send("POST", &format!("{base}/flow/runs/{number}/rerun"), &serde_json::json!({}))?;

            if json {

                println!("{started}");

            } else {

                println!("{} started run #{} {}", ui::ok("✔"), started["number"], ui::dim(started["url"].as_str().unwrap_or("")));

            }

        }

    }

    Ok(0)

}

fn release(c: &Client, t: &Target, cmd: ReleaseCmd, json: bool) -> Result<i32> {

    let base = t.repo_path()?;

    match cmd {

        ReleaseCmd::List => {

            let path = format!("{base}/releases");

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let list: Vec<Release> = c.get(&path)?;

            if list.is_empty() {

                println!("{}", ui::dim("No releases."));

            }

            for r in &list {

                println!(

                    "{} {} {}{}",

                    if r.latest { ui::ok("●") } else { ui::dim("○") },

                    ui::strong(&r.tag),

                    r.title,

                    ui::dim(&format!(

                        " · {} asset{} · {}",

                        r.assets.len(),

                        if r.assets.len() == 1 { "" } else { "s" },

                        ui::ago(r.created_ms)

                    ))

                );

            }

        }

        ReleaseCmd::Create { tag, title, notes, prerelease } => {

            let new = NewRelease { title: title.unwrap_or_else(|| tag.clone()), tag, notes, prerelease };

            let r: Release = c.send("POST", &format!("{base}/releases"), &new)?;

            if json {

                println!("{}", serde_json::to_string(&r)?);

            } else {

                println!("{} released {} {}", ui::ok("✔"), r.tag, ui::dim(&r.url));

            }

        }

        ReleaseCmd::Upload { tag, files } => {

            if files.is_empty() {

                bail!("name the files to attach");

            }

            for f in files {

                let name = f.file_name().and_then(|n| n.to_str()).context("a file name")?.to_string();

                let bytes = std::fs::read(&f).with_context(|| format!("read {}", f.display()))?;

                c.upload(&format!("{base}/releases/{}/assets?name={}", enc(&tag), enc(&name)), &bytes)?;

                println!("{} attached {name} to {tag}", ui::ok("✔"));

            }

        }

        ReleaseCmd::Trust { tag } => {

            let path = format!("{base}/releases/trust/{}", enc(&tag));

            if json {

                println!("{}", c.get_text(&path)?);

                return Ok(0);

            }

            let r: serde_json::Value = c.get(&path)?;

            println!("{} {}", ui::strong(&format!("Trust report for {tag}")), ui::dim(&format!("{} changes", r["changes"])));

            let mut worst = 0;

            for ch in r["audit"].as_array().into_iter().flatten() {

                let v = ch["verdict"].as_str().unwrap_or("");

                worst = worst.max(match v {

                    "fail" => 2,

                    "warn" => 1,

                    _ => 0,

                });

                let g = match v {

                    "pass" => ui::ok("✔"),

                    "warn" => ui::warn("!"),

                    _ => ui::bad("✘"),

                };

                println!("{g} {} {}", ch["title"].as_str().unwrap_or(""), ui::dim(ch["detail"].as_str().unwrap_or("")));

            }

            return Ok(if worst == 2 { 1 } else { 0 });

        }

    }

    Ok(0)

}

//! Which hub and repository a command talks to, and with which token.

//!

//! Inside an Oxygen checkout, `oh` uses the checkout's remote (`origin`, or

//! the only one, or `--remote NAME`): its URL names the hub and the

//! repository, and its token and CA are the ones `oxy` pushes with.

//! Elsewhere, `--repo OWNER/NAME` with the hub from `--hub`, `OH_HUB` or

//! the one `oh auth login` saved.

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

use serde::{Deserialize, Serialize};

use std::collections::BTreeMap;

use std::path::{Path, PathBuf};

/// `~/.config/oh/config.toml`: tokens and CAs by hub, and the default hub.

#[derive(Debug, Default, Serialize, Deserialize)]

pub struct Config {

    #[serde(default)]

    pub default_hub: Option<String>,

    #[serde(default)]

    pub hosts: BTreeMap<String, Host>,

}

#[derive(Clone, Debug, Default, Serialize, Deserialize)]

pub struct Host {

    pub token: String,

    #[serde(default)]

    pub ca: Option<PathBuf>,

}

pub fn config_path() -> Result<PathBuf> {

    if let Some(p) = std::env::var_os("OH_CONFIG") {

        return Ok(PathBuf::from(p));

    }

    let base = match std::env::var_os("XDG_CONFIG_HOME") {

        Some(d) => PathBuf::from(d),

        None => PathBuf::from(std::env::var_os("HOME").context("HOME is not set")?).join(".config"),

    };

    Ok(base.join("oh").join("config.toml"))

}

impl Config {

    pub fn load() -> Result<Config> {

        let p = config_path()?;

        match std::fs::read_to_string(&p) {

            Ok(t) => toml::from_str(&t).with_context(|| format!("parse {}", p.display())),

            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Config::default()),

            Err(e) => Err(e).with_context(|| format!("read {}", p.display())),

        }

    }

    /// Written owner-only: it holds tokens.

    pub fn save(&self) -> Result<()> {

        use std::io::Write;

        use std::os::unix::fs::OpenOptionsExt;

        let p = config_path()?;

        std::fs::create_dir_all(p.parent().unwrap())?;

        let tmp = p.with_extension("toml.tmp");

        let mut f = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(&tmp)?;

        f.write_all(toml::to_string_pretty(self)?.as_bytes())?;

        f.sync_all()?;

        std::fs::rename(&tmp, &p)?;

        Ok(())

    }

}

/// A hub, and a repository on it when the command needs one.

#[derive(Clone, Debug)]

pub struct Target {

    /// `https://host:port`, no trailing slash.

    pub hub: String,

    pub token: Option<String>,

    pub ca: Option<PathBuf>,

    pub owner: String,

    pub name: String,

}

impl Target {

    pub fn repo(&self) -> Result<(&str, &str)> {

        if self.owner.is_empty() {

            bail!("no repository: run inside an Oxygen checkout, or give --repo OWNER/NAME");

        }

        Ok((&self.owner, &self.name))

    }

    /// `/repos/{owner}/{name}`.

    pub fn repo_path(&self) -> Result<String> {

        let (o, n) = self.repo()?;

        Ok(format!("/repos/{o}/{n}"))

    }

}

/// Split `https://host:port/owner/name` into the hub and the repository.

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

    let (scheme, rest) = url.split_once("://").ok_or_else(|| anyhow!("{url} is not a hub URL"))?;

    let mut parts = rest.trim_end_matches('/').splitn(2, '/');

    let host = parts.next().unwrap_or("");

    let path = parts.next().unwrap_or("");

    let segs: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();

    match segs.as_slice() {

        [o, n] => Ok((format!("{scheme}://{host}"), o.to_string(), n.trim_end_matches(".oxy").to_string())),

        _ => bail!("{url} does not name a repository as https://hub/OWNER/NAME"),

    }

}

pub struct Choice<'a> {

    pub repo: Option<&'a str>,

    pub hub: Option<&'a str>,

    pub remote: Option<&'a str>,

}

/// Resolve what to talk to from the flags, the checkout at `dir`, the

/// environment and the saved configuration.

pub fn resolve(choice: &Choice, dir: &Path, cfg: &Config) -> Result<Target> {

    let env_token = std::env::var("OH_TOKEN").ok().or_else(|| std::env::var("OXY_TOKEN").ok()).filter(|t| !t.is_empty());

    let env_ca = std::env::var_os("OXY_CA").map(PathBuf::from);

    let saved = |hub: &str| cfg.hosts.get(hub).cloned();

    if let Some(r) = choice.repo {

        let (owner, name) = r.split_once('/').ok_or_else(|| anyhow!("--repo takes OWNER/NAME"))?;

        let hub = choice

            .hub

            .map(String::from)

            .or_else(|| std::env::var("OH_HUB").ok())

            .or_else(|| cfg.default_hub.clone())

            .ok_or_else(|| anyhow!("which hub? give --hub URL, set OH_HUB, or run `oh auth login`"))?;

        let hub = hub.trim_end_matches('/').to_string();

        let host = saved(&hub).unwrap_or_default();

        return Ok(Target {

            token: env_token.or(Some(host.token).filter(|t| !t.is_empty())),

            ca: env_ca.or(host.ca),

            hub,

            owner: owner.into(),

            name: name.into(),

        });

    }

    // The checkout's remote.

    if let Ok(repo) = oxy_core::repo::Repo::open(dir) {

        let remotes = &repo.config.remotes;

        let name = match choice.remote {

            Some(n) => n.to_string(),

            None if remotes.contains_key("origin") => "origin".into(),

            None if remotes.len() == 1 => remotes.keys().next().unwrap().clone(),

            None if remotes.is_empty() => bail!("this checkout has no remote; give --repo OWNER/NAME"),

            None => bail!(

                "this checkout has several remotes ({}); choose one with --remote",

                remotes.keys().cloned().collect::<Vec<_>>().join(", ")

            ),

        };

        let url = remotes.get(&name).ok_or_else(|| anyhow!("no remote named {name}"))?;

        let (hub, owner, repo_name) = split_url(url)?;

        let host = saved(&hub).unwrap_or_default();

        let token = env_token.or_else(|| repo.config.remote_tokens.get(&name).cloned()).or(Some(host.token).filter(|t| !t.is_empty()));

        let ca = env_ca.or_else(|| repo.config.remote_cas.get(&name).map(PathBuf::from)).or(host.ca);

        return Ok(Target { hub, token, ca, owner, name: repo_name });

    }

    // No repository: commands that need only a hub.

    let hub = choice

        .hub

        .map(String::from)

        .or_else(|| std::env::var("OH_HUB").ok())

        .or_else(|| cfg.default_hub.clone())

        .ok_or_else(|| anyhow!("not in an Oxygen checkout: give --repo OWNER/NAME and --hub URL, or run `oh auth login`"))?;

    let hub = hub.trim_end_matches('/').to_string();

    let host = saved(&hub).unwrap_or_default();

    Ok(Target {

        token: env_token.or(Some(host.token).filter(|t| !t.is_empty())),

        ca: env_ca.or(host.ca),

        hub,

        owner: String::new(),

        name: String::new(),

    })

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn remote_urls_name_the_hub_and_the_repository() {

        assert_eq!(

            split_url("https://earth.example:7343/andy/oxygen").unwrap(),

            ("https://earth.example:7343".into(), "andy".into(), "oxygen".into())

        );

        assert_eq!(split_url("http://127.0.0.1:9/a/b/").unwrap().2, "b");

        assert!(split_url("https://hub/only-owner").is_err());

        assert!(split_url("not a url").is_err());

    }

}

//! Output styling in the manner of `oxy`: colour and glyphs on a terminal,

//! plain text with `--plain`, `NO_COLOR` or when piped.

use std::io::IsTerminal;

use std::sync::OnceLock;

static PLAIN: OnceLock<bool> = OnceLock::new();

pub fn init(plain_flag: bool) {

    let plain = plain_flag || std::env::var_os("NO_COLOR").is_some_and(|v| !v.is_empty()) || !std::io::stdout().is_terminal();

    let _ = PLAIN.set(plain);

}

fn plain() -> bool {

    *PLAIN.get().unwrap_or(&true)

}

fn paint(code: &str, s: &str) -> String {

    if plain() {

        s.to_string()

    } else {

        format!("\x1b[{code}m{s}\x1b[0m")

    }

}

pub fn ok(s: &str) -> String {

    paint("32", s)

}

pub fn bad(s: &str) -> String {

    paint("31", s)

}

pub fn warn(s: &str) -> String {

    paint("35", s)

}

pub fn dim(s: &str) -> String {

    paint("2", s)

}

pub fn strong(s: &str) -> String {

    paint("1", s)

}

pub fn kv(key: &str, value: &str) -> String {

    format!("{} {value}", dim(&format!("{key:>16}")))

}

/// A run's or job's or check's status, as a glyph.

pub fn status(s: &str) -> String {

    match s {

        "passed" | "success" => ok("✔"),

        "failed" | "failure" | "error" => bad("✘"),

        "running" | "pending" => warn("●"),

        "queued" => dim("○"),

        "skipped" | "neutral" => dim("–"),

        _ => dim("?"),

    }

}

/// "3 minutes ago", as oxy says it.

pub fn ago(ms: i64) -> String {

    let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as i64).unwrap_or(0);

    let secs = (now - ms).max(0) / 1000;

    let unit = |n: i64, w: &str| format!("{n} {w}{} ago", if n == 1 { "" } else { "s" });

    match secs {

        0..=44 => "just now".into(),

        45..=89 => "a minute ago".into(),

        90..=2_699 => unit((secs + 59) / 60, "minute"),

        2_700..=5_399 => "an hour ago".into(),

        5_400..=79_199 => unit((secs + 3_599) / 3_600, "hour"),

        79_200..=129_599 => "yesterday".into(),

        _ => unit((secs + 86_399) / 86_400, "day"),

    }

}

//! `oh` against a real hub: signing in, finding the repository from a

//! checkout's remote, issues, Flow runs, releases and their trust report,

//! and the raw API.

use oxy_core::repo::{IdentityScope, Repo};

use oxygenhub::config::Config;

use oxygenhub::repos::RepoName;

use oxygenhub::{db, Shared};

use std::path::{Path, PathBuf};

const ROOTFS: &str = "36fc4e3238044e424219a2b9002bf61bbe1805fec14d52cf37e17fae77c9ff16";

fn hermetic() -> PathBuf {

    static DIR: std::sync::OnceLock<tempfile::TempDir> = std::sync::OnceLock::new();

    let d = DIR.get_or_init(|| tempfile::tempdir().unwrap());

    std::env::set_var("OXY_HOME", d.path());

    d.path().to_path_buf()

}

struct Hub {

    app: Shared,

    base: String,

    _dir: tempfile::TempDir,

}

async fn hub() -> Hub {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let mut config = Config::load(dir.path()).unwrap();

    config.auth.push_tokens = vec!["site".into()];

    config.flow.repos = vec!["andy/*".into()];

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let port = listener.local_addr().unwrap().port();

    config.server.base_url = format!("http://127.0.0.1:{port}");

    let app = oxygenhub::build(config).await.unwrap();

    let router = oxygenhub::router(app.clone());

    tokio::spawn(async move { axum_serve(listener, router).await });

    Hub { app, base: format!("http://127.0.0.1:{port}"), _dir: dir }

}

async fn axum_serve(listener: tokio::net::TcpListener, router: axum::Router) {

    axum::serve(listener, router).await.unwrap();

}

/// Run `oh` in `dir` with `env`; (exit code, stdout, stderr).

async fn oh(dir: &Path, env: &[(&str, &str)], args: &[&str]) -> (i32, String, String) {

    let (dir, env, args): (PathBuf, Vec<(String, String)>, Vec<String>) = (

        dir.to_path_buf(),

        env.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),

        args.iter().map(|a| a.to_string()).collect(),

    );

    tokio::task::spawn_blocking(move || {

        let out = std::process::Command::new(env!("CARGO_BIN_EXE_oh"))

            .args(&args)

            .current_dir(&dir)

            .env_remove("OH_TOKEN")

            .env_remove("OXY_TOKEN")

            .env_remove("OH_HUB")

            .envs(env)

            .output()

            .unwrap();

        (

            out.status.code().unwrap_or(-1),

            String::from_utf8_lossy(&out.stdout).into_owned(),

            String::from_utf8_lossy(&out.stderr).into_owned(),

        )

    })

    .await

    .unwrap()

}

fn write(root: &Path, rel: &str, content: &str) {

    let p = root.join(rel);

    std::fs::create_dir_all(p.parent().unwrap()).unwrap();

    std::fs::write(p, content).unwrap();

}

#[tokio::test(flavor = "multi_thread")]

async fn oh_drives_issues_runs_and_releases() {

    let h = hub().await;

    // The site token acts as the first site administrator.

    db::accounts::create_account(&h.app.db, "andy", "[email protected]", "x", "salt", true).await.unwrap();

    h.app.repos.create(&RepoName::parse("andy/demo").unwrap(), None).unwrap();

    db::repos::create(&h.app.db, "andy", "demo", "A demo", hub_api::Visibility::Public).await.unwrap();

    // A checkout whose origin is the hub: `oh` needs nothing else.

    let work = tempfile::tempdir().unwrap();

    let mut c = Repo::init(work.path()).unwrap();

    c.config.set("remote.origin.url", &format!("{}/andy/demo", h.base)).unwrap();

    c.config.set("remote.origin.token", "site").unwrap();

    c.save_config().unwrap();

    c.create_identity("Andy", "[email protected]", IdentityScope::Repo).unwrap();

    write(

        work.path(),

        ".flow/pipeline.kdl",

        &format!("schema-version 1\nsandbox \"alpine\" {{\n    rootfs \"cas://blob/{ROOTFS}\"\n}}\njob \"test\" {{\n    sandbox \"alpine\"\n    exec \"true\"\n}}\n"),

    );

    c.snapshot("test").unwrap();

    c.commit("Add a pipeline", &[]).unwrap();

    let heads = c.bookmark_heads().unwrap();

    c.tag_create("v1", &heads, "first").unwrap();

    assert!(c.push("origin", false).unwrap().iter().all(|r| r.ok));

    let w = work.path();

    let (code, out, err) = oh(w, &[], &["repo", "view", "--plain"]).await;

    assert_eq!(code, 0, "{err}");

    assert!(out.contains("andy/demo") && out.contains("A demo") && out.contains("oxy clone"), "{out}");

    // Issues.

    let (code, out, err) = oh(w, &[], &["issue", "create", "--title", "Broken thing", "--body", "It breaks."]).await;

    assert_eq!(code, 0, "{err}");

    assert!(out.contains("opened #1"), "{out}");

    let (_, out, _) = oh(w, &[], &["issue", "list", "--json"]).await;

    let list: serde_json::Value = serde_json::from_str(&out).unwrap();

    assert_eq!((list[0]["number"].as_i64(), list[0]["title"].as_str()), (Some(1), Some("Broken thing")));

    let (_, out, _) = oh(w, &[], &["issue", "comment", "1", "--body", "Seen it too."]).await;

    assert!(out.contains("commented on #1"));

    let (_, out, _) = oh(w, &[], &["issue", "view", "1", "--plain"]).await;

    assert!(out.contains("It breaks.") && out.contains("Seen it too."), "{out}");

    let (_, out, _) = oh(w, &[], &["issue", "close", "1"]).await;

    assert!(out.contains("closed #1"));

    let (_, out, _) = oh(w, &[], &["issue", "list", "--plain"]).await;

    assert!(out.contains("No open issues."), "{out}");

    // Flow: the push started run 1; start another without a push.

    let (code, out, err) = oh(w, &[], &["run", "start"]).await;

    assert_eq!(code, 0, "{err}");

    assert!(out.contains("started run #2"), "{out}");

    let (_, out, _) = oh(w, &[], &["run", "list", "--json"]).await;

    let runs: serde_json::Value = serde_json::from_str(&out).unwrap();

    assert_eq!(runs.as_array().unwrap().len(), 2);

    let (_, out, _) = oh(w, &[], &["run", "view", "2", "--plain"]).await;

    assert!(out.contains("test") && out.contains("#2"), "{out}");

    // Releases, an asset, and the trust report.

    let (code, out, err) = oh(w, &[], &["release", "create", "v1", "--title", "One", "--notes", "First."]).await;

    assert_eq!(code, 0, "{err}");

    assert!(out.contains("released v1"), "{out}");

    let asset = w.join("tool.bin");

    std::fs::write(&asset, b"bytes").unwrap();

    let (code, out, err) = oh(w, &[], &["release", "upload", "v1", asset.to_str().unwrap()]).await;

    assert_eq!(code, 0, "{err}");

    assert!(out.contains("attached tool.bin to v1"));

    let (_, out, _) = oh(w, &[], &["release", "list", "--json"]).await;

    let rel: serde_json::Value = serde_json::from_str(&out).unwrap();

    assert_eq!(rel[0]["assets"][0]["name"], "tool.bin");

    let (code, out, _) = oh(w, &[], &["release", "trust", "v1", "--plain"]).await;

    assert_eq!(code, 0, "warnings only: {out}");

    assert!(out.contains("Tag v1 is signed") && out.contains("tool.bin: no build found"), "{out}");

    // Outside a checkout: --repo and a saved login.

    let elsewhere = tempfile::tempdir().unwrap();

    let cfg = elsewhere.path().join("oh.toml");

    let cfg_s = cfg.to_str().unwrap();

    let (code, _, err) = oh(elsewhere.path(), &[("OH_CONFIG", cfg_s)], &["issue", "list"]).await;

    assert_ne!(code, 0);

    assert!(err.contains("--repo"), "{err}");

    let (code, out, err) =

        oh(elsewhere.path(), &[("OH_CONFIG", cfg_s)], &["auth", "login", "--with-hub", &h.base, "--token", "site"]).await;

    assert_eq!(code, 0, "{err}");

    assert!(out.contains("signed in"), "{out}");

    #[cfg(unix)]

    {

        use std::os::unix::fs::PermissionsExt;

        assert_eq!(std::fs::metadata(&cfg).unwrap().permissions().mode() & 0o777, 0o600, "tokens are owner-only");

    }

    let (code, out, _) =

        oh(elsewhere.path(), &[("OH_CONFIG", cfg_s)], &["issue", "list", "--state", "all", "--repo", "andy/demo", "--plain"]).await;

    assert_eq!(code, 0);

    assert!(out.contains("Broken thing"), "{out}");

    let (code, out, _) = oh(elsewhere.path(), &[("OH_CONFIG", cfg_s)], &["api", "/repos/andy/demo/labels"]).await;

    assert_eq!(code, 0);

    assert!(out.trim_start().starts_with('['), "{out}");

    // A bad token says what to do.

    let (code, _, err) = oh(w, &[("OXY_TOKEN", "nope")], &["issue", "create", "--title", "x"]).await;

    assert_ne!(code, 0);

    assert!(err.contains("HTTP 401") && err.contains("oh auth login"), "{err}");

}

# oh: OxygenHub from the command line

`oh` is to OxygenHub what `gh` is to GitHub. It talks to the hub's JSON API

(hub spec §12) and prints what it gets back: in colour on a terminal, as

plain text with `--plain` or `NO_COLOR`, and as the API's own JSON with

`--json`.

## Which hub, which repository, which token

Inside an Oxygen checkout, `oh` uses the checkout's remote:

- **Remote:** `origin`, or the only remote, or `--remote NAME`.

- **Hub and repository:** from the remote's URL (`https://hub/OWNER/NAME`).

- **Token and CA:** the ones `oxy` pushes with (`remote.NAME.token`, `remote.NAME.ca`).

So in a checkout that pushes to the hub, `oh` needs no setup.

Elsewhere, sign in once and name the repository:

```

oh auth login --with-hub https://earth.andymccall.xyz:7343 --ca ~/.config/oxy/earth-ca.pem

oh issue list --repo andymccall/oxygen

```

`oh auth login` checks the token, saves it with the CA in

`~/.config/oh/config.toml` (owner-only), and makes that hub the default. It

reads the token from stdin unless `--token` is given. `OH_TOKEN` (or

`OXY_TOKEN`), `OH_HUB` and `OXY_CA` override the saved values.

## Commands

| Command | What it does |

|---|---|

| `oh auth login`, `oh auth status` | Save a token; show who you are |