[type.codespell]

check-file = false

extend-glob = [".codespellrc"]

* `radicle-crdt`: Conflict-free replicated datatypes (CRDTs) used for things like discussions and patches.

* `radicle-crypto`: A wrapper around Ed25519 cryptographic signing primitives.

* `radicle-dag`: A simple directed acyclic graph implementation used by `radicle-cob`.

* `radicle-remote-helper`: A Git remote helper for `rad://` remotes.

* `radicle-term`: A generic terminal library used by the Radicle CLI.

* `radicle-tools`: Tools used to aid in the development of Radicle.

To view all options, run `cargo run -p radicle-node -- --help`.

You may want to set the appropriate environment variables before running these commands

following section on environment variables.

## Running in isolation

## Environment variables

development environment more friendly.

**`RAD_HOME`**

and repositories. Typically you'll want to set this to a temporary folder, eg.

stored within this folder.

**`RAD_KEYGEN_SEED`**

Radicle stores git repositories inside `$RAD_HOME/storage`, which defaults to

`~/.radicle/storage` on UNIX-based operating systems. You can use standard git

repository is stored under its own folder under storage as a bare Git repository.

Once inside a repository folder, the following commands may come in handy.

### Connecting to your local node

`$RAD_HOME/node/control.sock`. Make sure this file is accessible and has the

required permissions for your user to read and write to it.

encoded in the standard OpenSSH format. It's therefore possible to use standard

OpenSSH tools to interact with them, eg. `ssh-add`.

```

$ rad auth --alias "alice"

✓ Creating your Ed25519 keypair...

✓ Your Radicle DID is did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi. This identifies your device. Run `rad self` to show it at all times.

`clone` command, followed by the identifier or *RID* of the repository:

```

`clone` command, followed by the identifier or *RID* of the repository:

```

{

  "$schema": "https://json-schema.org/draft/2020-12/schema",

  "title": "Config",

  "type": "object",

  "properties": {

    "publicExplorer": {

```

$ rad init --setup-signing --existing rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji

✓ Signing configured in [..]/heartwood/config

! Not writing .gitsigners file.

```

$ rad init --setup-signing --existing rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji

✓ Signing configured in [..]/heartwood/.git/config

✓ Created .gitsigners file

```

$ rad init --name heartwood --description "radicle heartwood protocol & stack" --no-confirm --public --no-seed

✓ Repository heartwood created.

```

$ rad init --name heartwood --description "radicle heartwood protocol & stack" --no-confirm --private --no-seed

✓ Repository heartwood created.

```

$ rad init --name heartwood --description "radicle heartwood protocol & stack" --no-confirm --private

✓ Repository heartwood created.

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public --scope followed

✓ Repository heartwood created.

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public --scope followed

✓ Repository heartwood created.

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public --scope followed

✓ Repository heartwood created.

the `init` command:

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public --scope followed

✓ Repository heartwood created.

```

$ rad init --name heartwood --description "Heartwood Protocol & Stack" --no-confirm --public

✓ Repository heartwood created.

`init` command.  Make sure you have [authenticated](../rad-auth.md) beforehand.

```

$ rad init --name heartwood --description "Radicle Heartwood Protocol & Stack" --no-confirm --public -v

✓ Repository heartwood created.

{

``` (fail)

$ rad self

✗ Error: Radicle profile not found in '[..]'.

```

```

process. It allows us to interact with the network as well as storing

some key data that we may be interested in.

``` ~alice

$ rad init --name heartwood --description "radicle heartwood protocol & stack" --no-confirm --public

✓ Repository heartwood created.

Back to being the project maintainer.

changes from another peer, we must first follow them, and then create

a tracking branch in our working copy. The `rad remote add` command does all

of this.

}

pub fn init(args: Args) -> anyhow::Result<()> {

    if let Ok(version) = radicle::git::version() {

        if version < radicle::git::VERSION_REQUIRED {

    if let Some(passphrase) = passphrase {

        match ssh::agent::Agent::connect() {

            Ok(mut agent) => {

                if register(&mut agent, &profile, passphrase).is_ok() {

                    spinner.finish();

                } else {

                    spinner.warn();

                }

            }

const ABOUT: &str = "Manage your local Radicle configuration";

const LONG_ABOUT: &str = r#"

To initialize a new configuration file, use `rad config init`.

"#;

#[derive(Subcommand, Debug)]

#[group(multiple = false)]

pub(crate) enum Command {

    Show,

    /// Initialize a new config file

    Init {

    };

    term::headline(format!(

        match visibility {

            Some(ref visibility) => term::format::spaced(term::format::visibility(visibility)),

            None => term::format::default(" ").into(),

            }

            if args.setup_signing {

                self::setup_signing(profile.id(), &repo, interactive)?;

            }

    }

    if args.setup_signing {

        self::setup_signing(profile.id(), &working, interactive)?;

    }

    Ok(())

}

pub fn setup_signing(

    node_id: &NodeId,

    repo: &git::Repository,

    let key = ssh::fmt::fingerprint(node_id);

    let yes = if !git::is_signing_configured(path)? {

        term::headline(format!(

            term::format::tertiary(key)

        ));

        true

    } else if interactive.yes() {

        term::confirm(format!(

            term::format::tertiary(key),

            term::format::tertiary(config.display()),

        ))

    /// Setup the upstream of the default branch

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

    pub(super) set_upstream: bool,

    #[arg(long)]

    pub(super) setup_signing: bool,

    /// Don't ask for confirmation during setup

    Ok(git(repo, ["config", CONFIG_SIGNING_KEY]).is_ok())

}

pub fn rad_remotes(repo: &Repository) -> anyhow::Result<Vec<Remote<'_>>> {

    let remotes: Vec<_> = repo

        .remotes()?

    match radicle::rad::remote(repo) {

        Ok((remote, id)) => Ok((remote, id)),

        Err(radicle::rad::RemoteError::NotFound(_)) => Err(anyhow!(

        )),

        Err(err) => Err(err).context("could not read git remote configuration"),

    }

            Ok(profile) => Ok(profile),

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

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

            )

            .into()),

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

        }

    }

}

    }

    /// Parse an identifier from the human-readable URN format.

    /// for convenience.

    pub fn from_urn(s: &str) -> Result<Self, IdError> {

        let s = s.strip_prefix(RAD_PREFIX).unwrap_or(s);

    verbosity: Verbosity,

}

fn run(profile: radicle::Profile) -> Result<(), Error> {

    // Since we're going to be writing user output to `stderr`, make sure the paint

    // module is aware of that.

        .with_display_mode(inquire::PasswordDisplayMode::Masked)

        .with_custom_confirmation_message("Repeat passphrase:")

        .with_custom_confirmation_error_message("The passphrases don't match.")

        .prompt()

    {

        Ok(p) => Ok(Some(Passphrase::from(p))),

    Ok(tree)

}

///

/// * Sets `push.default = upstream`.

pub fn configure_repository(repo: &raw::Repository) -> Result<(), raw::Error> {

    Ok(())

}

///

/// The entry for this remote will be:

/// ```text

/// Peer-to-peer protocol version.

pub const PROTOCOL_VERSION: u8 = 1;

pub const DEFAULT_PORT: u16 = 8776;

/// Default timeout when waiting for an event to be received on the

/// [`Handle::subscribe`] channel.

use crate::storage::git::transport;

use crate::{cob, git, node, storage};

pub mod env {

    pub use std::env::*;

    pub const RAD_HOME: &str = "RAD_HOME";

    pub const RAD_SOCKET: &str = "RAD_SOCKET";

    pub const RAD_PASSPHRASE: &str = "RAD_PASSPHRASE";

    /// RNG seed. Must be convertible to a `u64`.

    pub const RAD_RNG_SEED: &str = "RAD_RNG_SEED";

    /// Private key seed. Used for generating deterministic keypairs.

    pub const RAD_KEYGEN_SEED: &str = "RAD_KEYGEN_SEED";

    pub const RAD_HINT: &str = "RAD_HINT";

    /// Environment variable to set to overwrite the commit date for both

    /// the author and the committer.

        None

    }

    pub fn passphrase() -> Option<super::Passphrase> {

        let Ok(passphrase) = var(RAD_PASSPHRASE) else {

            return None;

    Routing(#[from] node::routing::Error),

    #[error(transparent)]

    Keystore(#[from] keystore::Error),

    NotFound(PathBuf),

    #[error(transparent)]

    PolicyStore(#[from] node::policy::store::Error),

    #[error(transparent)]

    Agent(#[from] crate::crypto::ssh::agent::AgentError),

    KeyNotRegistered(PublicKey),

    #[error(transparent)]

        }

    }

    pub fn home(&self) -> &Home {

        &self.home

    }

    }

}

pub fn home() -> Result<Home, io::Error> {

    #[cfg(unix)]

    const ERROR_MESSAGE_UNSET: &str =

    },

}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

#[serde(rename_all = "camelCase")]

#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]

use crate::storage::{WriteRepository, WriteStorage};

use crate::{identity, storage};

pub static REMOTE_NAME: LazyLock<git::fmt::RefString> = LazyLock::new(|| git::fmt::refname!("rad"));

pub static REMOTE_COMPONENT: LazyLock<git::fmt::Component> =

    LazyLock::new(|| git::fmt::component!("rad"));

/// Refname used for pushing patches.

    Storage(#[from] storage::Error),

}

pub fn init<G, S>(

    repo: &git::raw::Repository,

    name: ProjectName,

    let repo = git::raw::Repository::init_opts(path.as_ref(), &opts)?;

    let url = git::Url::from(proj);

    git::configure_repository(&repo)?;

    // Configure and fetch all refs from remote.

    git::configure_remote(

    RidMismatch { found: RepoId, expected: RepoId },

}

pub fn remote(repo: &git::raw::Repository) -> Result<(git::raw::Remote<'_>, RepoId), RemoteError> {

    let remote = repo.find_remote(&REMOTE_NAME).map_err(|e| {

        if e.code() == git::raw::ErrorCode::NotFound {

    Ok((remote, url.repo))

}

pub fn remove_remote(repo: &git::raw::Repository) -> Result<(), RemoteError> {

    repo.remote_delete(&REMOTE_NAME).map_err(|e| {

        if e.code() == git::raw::ErrorCode::NotFound {

pub mod mock;

pub mod url;

use crate::storage::git::transport;

use crate::storage::refs::SignedRefs;

pub const RADICLE_EPOCH: i64 = 1514817556;

const USER_NAME: &str = "anonymous";