"radicle-crypto",

 "radicle-git-ext",

 "radicle-ssh",

 "serde",

 "serde_json",

 "siphasher 1.0.1",

 "radicle-node",

 "radicle-surf",

 "radicle-term",

 "serde",

 "serde_json",

 "shlex",

]

[[package]]

name = "scopeguard"

version = "1.2.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

]

[[package]]

name = "serde_json"

version = "1.0.116"

source = "registry+https://github.com/rust-lang/crates.io-index"

tree-sitter-go = { version = "0.23.4" }

tree-sitter-md = { version = "0.3.2" }

zeroize = { version = "1.1" }

[dependencies.radicle]

version = "0"

use std::path::Path;

use std::str::FromStr;

use anyhow::anyhow;

use radicle::node::Alias;

use radicle::profile::{Config, ConfigError, ConfigPath, RawConfig};

    rad config init --alias <alias> [<option>...]

    rad config edit [<option>...]

    rad config get <key> [<option>...]

    rad config set <key> <value> [<option>...]

    rad config unset <key> [<option>...]

    rad config push <key> <value> [<option>...]

    #[default]

    Show,

    Get(String),

    Set(String, String),

    Push(String, String),

    Remove(String, String),

                }

                Value(val) if op.is_none() => match val.to_string_lossy().as_ref() {

                    "show" => op = Some(Operation::Show),

                    "edit" => op = Some(Operation::Edit),

                    "init" => op = Some(Operation::Init),

                    "get" => {

            let profile = ctx.profile()?;

            term::json::to_pretty(&profile.config, path.as_path())?.print();

        }

        Operation::Get(key) => {

            let mut temp_config = RawConfig::from_file(&path)?;

            let key: ConfigPath = key.into();

tempfile = { version = "3.3.0" }

thiserror = { version = "1" }

unicode-normalization = { version = "0.1" }

[dependencies.chrono]

version = "0.4.0"

/// CLI configuration.

#[serde(rename_all = "camelCase")]

pub struct Config {

    /// Whether to show hints or not in the CLI.

use std::str::FromStr;

use thiserror::Error;

use crate::prelude::RepoId;

}

/// A public explorer, eg. `https://app.radicle.xyz`.

#[serde(transparent)]

pub struct Explorer(String);

use std::{ffi::OsString, fmt, str::FromStr};

use git_ext::ref_format::{Component, RefString};

use thiserror::Error;

use crate::git;

    Multibase(#[from] multibase::Error),

}

/// A repository identifier.

impl fmt::Display for RepoId {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

use amplify::WrapperMut;

use cyphernet::addr::NetAddr;

use localtime::{LocalDuration, LocalTime};

use serde::de::DeserializeOwned;

use serde::{Deserialize, Serialize};

use serde_json as json;

}

/// Node alias.

#[serde(try_from = "String", into = "String")]

pub struct Alias(String);

}

/// Peer public protocol address.

#[wrapper(Deref, Display, FromStr)]

#[wrapper_mut(DerefMut)]

impl Address {

    /// Check whether this address is from the local network.

use std::str::FromStr;

use std::{fmt, net};

use cyphernet::addr::PeerAddr;

use localtime::LocalDuration;

use serde_json as json;

}

/// Peer-to-peer network.

#[serde(rename_all = "camelCase")]

pub enum Network {

    #[default]

}

/// Configuration parameters defining attributes of minima and maxima.

#[serde(rename_all = "camelCase")]

pub struct Limits {

    /// Number of routing table entries before we start pruning.

    pub routing_max_size: usize,

    /// How long to keep a routing table entry before being pruned.

    #[serde(with = "crate::serde_ext::localtime::duration")]

    pub routing_max_age: LocalDuration,

    /// How long to keep a gossip message entry before pruning it.

    #[serde(with = "crate::serde_ext::localtime::duration")]

    pub gossip_max_age: LocalDuration,

    /// Maximum number of concurrent fetches per peer connection.

    pub fetch_concurrency: usize,

    }

}

/// Limiter for byte streams.

///

/// Default: 500MiB

#[serde(rename_all = "camelCase")]

#[serde(into = "String", try_from = "String")]

pub struct FetchPackSizeLimit {

    limit: bytesize::ByteSize,

}

}

/// Connection limits.

#[serde(rename_all = "camelCase")]

pub struct ConnectionLimits {

    /// Max inbound connections.

}

/// Rate limts for a single connection.

#[serde(rename_all = "camelCase")]

pub struct RateLimit {

    pub fill_rate: f64,

}

/// Rate limits for inbound and outbound connections.

#[serde(rename_all = "camelCase")]

pub struct RateLimits {

    pub inbound: RateLimit,

}

/// Full address used to connect to a remote node.

#[serde(transparent)]

impl From<PeerAddr<NodeId, Address>> for ConnectAddress {

    fn from(value: PeerAddr<NodeId, Address>) -> Self {

}

/// Peer configuration.

#[serde(rename_all = "camelCase", tag = "type")]

pub enum PeerConfig {

    /// Static peer set. Connect to the configured peers and maintain the connections.

}

/// Relay configuration.

#[serde(rename_all = "camelCase")]

pub enum Relay {

    /// Always relay messages.

}

/// Proxy configuration.

#[serde(rename_all = "camelCase", tag = "mode")]

pub enum AddressConfig {

    /// Proxy connections to this address type.

}

/// Default seeding policy. Applies when no repository policies for the given repo are found.

#[serde(rename_all = "camelCase", tag = "default")]

pub enum DefaultSeedingPolicy {

    /// Allow seeding.

}

/// Service configuration.

#[serde(rename_all = "camelCase")]

pub struct Config {

    /// Node alias.

    /// Log level.

    #[serde(default = "defaults::log")]

    #[serde(with = "crate::serde_ext::string")]

    pub log: log::Level,

    /// Whether or not our node should relay messages.

    #[serde(default, deserialize_with = "crate::serde_ext::ok_or_default")]

pub mod config;

pub mod store;

use std::fmt;

use std::str::FromStr;

}

/// Follow scope of a seeded repository.

#[serde(rename_all = "camelCase")]

pub enum Scope {

    /// Seed remotes that are explicitly followed.

use std::path::Path;

use std::{fmt, fs, io};

use serde::Serialize as _;

use serde_json as json;

use thiserror::Error;

}

/// Local radicle configuration.

#[serde(rename_all = "camelCase")]

pub struct Config {

    /// Public explorer. This is used for generating links.

            .parse()

            .map_err(de::Error::custom)

    }

}

/// Unlike the default `serde` instances from `localtime`, this encodes and decodes using seconds

            Ok(LocalDuration::from_secs(seconds))

        }

    }

}

mod test {

    use super::*;

    #[test]

    fn test_localtime() {

use crate::prelude::RepoId;

/// Web configuration.

#[serde(rename_all = "camelCase")]

pub struct Config {

    /// Pinned content.

/// Pinned content. This can be used to pin certain content when

/// listing, e.g. pin repositories on a web client.

#[serde(rename_all = "camelCase")]

pub struct Pinned {

    /// Pinned repositories.