version = "1.0.81"

checksum = "6c6b2562119bf28c3439f7f02db99faf0aa1a8cdfe5772a2ee155d32227239f0"

version = "1.2.0"

checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652"

version = "0.4.0"

checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"

version = "2.3.0"

checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"

 "radicle-surf",

version = "0.4.1"

checksum = "5082dc942361cdfb74eab98bf995762d6015e5bb3a20bf7c5c71213778b4fcb4"

version = "2.4.0"

checksum = "50bff7831e19200a85b17131d085c25d7811bc4e186efdaf54bbd132994a88cb"

radicle-term = { version = "0.9.0", package = "radicle-term" }

use crate::terminal;

use crate::terminal::args::{Args, Error, Help};

pub async fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()> {

            let profile = terminal::profile()?;

use radicle::identity::RepoId;

use crate::terminal;

use crate::terminal::args::{Args, Error, Help};

pub async fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()> {

            let profile = terminal::profile()?;

use crate::terminal;

use crate::terminal::args::{Args, Error, Help};

pub async fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()> {

            let profile = terminal::profile()?;

mod terminal;

pub mod args;

pub mod io;

use std::ffi::OsString;

use std::process;

pub use args::{Args, Error, Help};

use radicle_term as term;

use radicle::profile::{Home, Profile};

/// Context passed to all commands.

pub trait Context {

    /// Return the currently active profile, or an error if no profile is active.

    fn profile(&self) -> Result<Profile, anyhow::Error>;

    /// Return the Radicle home.

    fn home(&self) -> Result<Home, std::io::Error>;

}

impl Context for Profile {

    fn profile(&self) -> Result<Profile, anyhow::Error> {

        Ok(self.clone())

    }

    fn home(&self) -> Result<Home, std::io::Error> {

        Ok(self.home.clone())

    }

}

pub struct DefaultContext;

impl Context for DefaultContext {

    fn home(&self) -> Result<Home, std::io::Error> {

        radicle::profile::home()

    }

    fn profile(&self) -> Result<Profile, anyhow::Error> {

        match Profile::load() {

            Ok(profile) => Ok(profile),

            Err(radicle::profile::Error::NotFound(path)) => Err(args::Error::WithHint {

                err: anyhow::anyhow!("Radicle profile not found in '{}'.", path.display()),

                hint: "To setup your radicle profile, run `rad auth`.",

            }

            .into()),

            Err(radicle::profile::Error::Config(e)) => Err(e.into()),

            Err(e) => Err(anyhow::anyhow!("Could not load radicle profile: {e}")),

        }

    }

}

/// A command that can be run.

pub trait Command<A: Args, C: Context> {

    /// Run the command, given arguments and a context.

    fn run(self, args: A, context: C) -> anyhow::Result<()>;

}

impl<F, A: Args, C: Context> Command<A, C> for F

where

    F: FnOnce(A, C) -> anyhow::Result<()>,

{

    fn run(self, args: A, context: C) -> anyhow::Result<()> {

        self(args, context)

    }

}

pub fn run_command_args<A, C>(help: Help, cmd: C, args: Vec<OsString>) -> !

where

    A: Args,

    C: Command<A, DefaultContext>,

{

    let options = match A::from_args(args) {

        Ok((opts, unparsed)) => {

            if let Err(err) = args::finish(unparsed) {

                term::error(err);

                process::exit(1);

            }

            opts

        }

        Err(err) => {

            let hint = match err.downcast_ref::<Error>() {

                Some(Error::Help) => {

                    term::help(help.name, help.version, help.description, help.usage);

                    process::exit(0);

                }

                Some(Error::HelpManual { name }) => {

                    let Ok(status) = term::manual(name) else {

                        term::error(format!("rad-tui {}: failed to load manual page", help.name));

                        process::exit(1);

                    };

                    process::exit(status.code().unwrap_or(0));

                }

                Some(Error::Usage) => {

                    term::usage(help.name, help.usage);

                    process::exit(1);

                }

                Some(Error::WithHint { hint, .. }) => Some(hint),

                None => None,

            };

            term::error(format!("rad-tui {}: {err}", help.name));

            if let Some(hint) = hint {

                term::hint(hint);

            }

            process::exit(1);

        }

    };

    match cmd.run(options, DefaultContext) {

        Ok(()) => process::exit(0),

        Err(err) => {

            fail(help.name, &err);

            process::exit(1);

        }

    }

}

/// Get the default profile. Fails if there is no profile.

pub fn profile() -> Result<Profile, anyhow::Error> {

    match Profile::load() {

        Ok(profile) => Ok(profile),

        Err(radicle::profile::Error::NotFound(path)) => Err(args::Error::WithHint {

            err: anyhow::anyhow!("Radicle profile not found in '{}'.", path.display()),

            hint: "To setup your radicle profile, run `rad auth`.",

        }

        .into()),

        Err(radicle::profile::Error::Config(e)) => Err(e.into()),

        Err(e) => Err(anyhow::anyhow!("Could not load radicle profile: {e}")),

    }

}

pub fn fail(_name: &str, error: &anyhow::Error) {

    let err = error.to_string();

    let err = err.trim_end();

    for line in err.lines() {

        term::error(line);

    }

    if let Some(Error::WithHint { hint, .. }) = error.downcast_ref::<Error>() {

        term::hint(hint);

    }

}

use std::ffi::OsString;

use std::str::FromStr;

use anyhow::anyhow;

use radicle::cob::{issue, patch};

use radicle::crypto;

use radicle::identity::{Did, RepoId};

/// Git revision parameter. Supports     extended SHA-1 syntax.

#[derive(Debug, Clone, PartialEq, Eq)]

pub struct Rev(String);

impl From<String> for Rev {

    fn from(value: String) -> Self {

        Rev(value)

    }

}

#[derive(thiserror::Error, Debug)]

#[allow(dead_code)]

pub enum Error {

    /// If this error is returned from argument parsing, help is displayed.

    #[error("help invoked")]

    Help,

    /// If this error is returned from argument parsing, the manual page is displayed.

    #[error("help manual invoked")]

    HelpManual { name: &'static str },

    /// If this error is returned from argument parsing, usage is displayed.

    #[error("usage invoked")]

    Usage,

    /// An error with a hint.

    #[error("{err}")]

    WithHint {

        err: anyhow::Error,

        hint: &'static str,

    },

}

pub struct Help {

    pub name: &'static str,

    pub description: &'static str,

    pub version: &'static str,

    pub usage: &'static str,

}

pub trait Args: Sized {

    fn from_env() -> anyhow::Result<Self> {

        let args: Vec<_> = std::env::args_os().skip(1).collect();

        match Self::from_args(args) {

            Ok((opts, unparsed)) => {

                self::finish(unparsed)?;

                Ok(opts)

            }

            Err(err) => Err(err),

        }

    }

    fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)>;

}

#[allow(dead_code)]

pub fn parse_value<T: FromStr>(flag: &str, value: OsString) -> anyhow::Result<T>

where

    <T as FromStr>::Err: std::error::Error,

{

    value

        .into_string()

        .map_err(|_| anyhow!("the value specified for '--{}' is not valid UTF-8", flag))?

        .parse()

        .map_err(|e| anyhow!("invalid value specified for '--{}' ({})", flag, e))

}

#[allow(dead_code)]

pub fn format(arg: lexopt::Arg) -> OsString {

    match arg {

        lexopt::Arg::Long(flag) => format!("--{flag}").into(),

        lexopt::Arg::Short(flag) => format!("-{flag}").into(),

        lexopt::Arg::Value(val) => val,

    }

}

#[allow(dead_code)]

pub fn finish(unparsed: Vec<OsString>) -> anyhow::Result<()> {

    if let Some(arg) = unparsed.first() {

        return Err(anyhow::anyhow!(

            "unexpected argument `{}`",

            arg.to_string_lossy()

        ));

    }

    Ok(())

}

pub fn string(val: &OsString) -> String {

    val.to_string_lossy().to_string()

}

#[allow(dead_code)]

pub fn rev(val: &OsString) -> anyhow::Result<Rev> {

    let s = val.to_str().ok_or(anyhow!("invalid git rev {val:?}"))?;

    Ok(Rev::from(s.to_owned()))

}

#[allow(dead_code)]

pub fn did(val: &OsString) -> anyhow::Result<Did> {

    let val = val.to_string_lossy();

    let Ok(peer) = Did::from_str(&val) else {

        if crypto::PublicKey::from_str(&val).is_ok() {

            return Err(anyhow!("expected DID, did you mean 'did:key:{val}'?"));

        } else {

            return Err(anyhow!("invalid DID '{}', expected 'did:key'", val));

        }

    };

    Ok(peer)

}

pub fn rid(val: &OsString) -> anyhow::Result<RepoId> {

    let val = val.to_string_lossy();

    RepoId::from_str(&val).map_err(|_| anyhow!("invalid Repository ID '{}'", val))

}

#[allow(dead_code)]

pub fn issue(val: &OsString) -> anyhow::Result<issue::IssueId> {

    let val = val.to_string_lossy();

    issue::IssueId::from_str(&val).map_err(|_| anyhow!("invalid Issue ID '{}'", val))

}

#[allow(dead_code)]

pub fn patch(val: &OsString) -> anyhow::Result<patch::PatchId> {

    let val = val.to_string_lossy();

    patch::PatchId::from_str(&val).map_err(|_| anyhow!("invalid Patch ID '{}'", val))

}

use radicle::crypto::ssh::keystore::MemorySigner;

use radicle::crypto::{ssh::Keystore, Signer};

use radicle::profile::env::RAD_PASSPHRASE;

use radicle::profile::Profile;

use radicle_term::io::*;

use radicle_term::spinner;

use inquire::validator;

/// Validates secret key passphrases.

#[derive(Clone)]

pub struct PassphraseValidator {

    keystore: Keystore,

}

#[allow(dead_code)]

impl PassphraseValidator {

    /// Create a new validator.

    pub fn new(keystore: Keystore) -> Self {

        Self { keystore }

    }

}

impl inquire::validator::StringValidator for PassphraseValidator {

    fn validate(

        &self,

        input: &str,

    ) -> Result<validator::Validation, inquire::error::CustomUserError> {

        let passphrase = Passphrase::from(input.to_owned());

        if self.keystore.is_valid_passphrase(&passphrase)? {

            Ok(validator::Validation::Valid)

        } else {

            Ok(validator::Validation::Invalid(

                validator::ErrorMessage::from("Invalid passphrase, please try again"),

            ))

        }

    }

}

/// Get the signer. First we try getting it from ssh-agent, otherwise we prompt the user,

/// if we're connected to a TTY.

#[allow(dead_code)]

pub fn signer(profile: &Profile) -> anyhow::Result<Box<dyn Signer>> {

    if let Ok(signer) = profile.signer() {

        return Ok(signer);

    }

    let validator = PassphraseValidator::new(profile.keystore.clone());

    let passphrase = match passphrase(validator) {

        Ok(p) => p,

        Err(inquire::InquireError::NotTTY) => {

            return Err(anyhow::anyhow!(

                "running in non-interactive mode, please set `{RAD_PASSPHRASE}` to unseal your key",

            ));

        }

        Err(e) => return Err(e.into()),

    };

    let spinner = spinner("Unsealing key...");

    let signer = MemorySigner::load(&profile.keystore, Some(passphrase))?;

    spinner.finish();

    Ok(signer.boxed())

}