```

$ cd heartwood

$ git branch -r

  rad/master

```

```

145e1e69bef3ad93d14946ea212249c2fa9b9828	refs/heads/alice/1

f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354	refs/heads/master

```

``` (stderr)

From rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

```

```

$ git branch -r

  rad/master

```

```

145e1e69bef3ad93d14946ea212249c2fa9b9828

```

The example below is run with `RAD_PASSPHRASE` set.

```

Initializing your radicle 👾 identity

$ rad self --did

did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

```

✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi..

✓ Forking under z6Mkux1…nVhib7Z..

✓ Creating checkout in ./heartwood..

✓ Repository successfully cloned under [..]/heartwood/

```

```

$ git fetch --all

Fetching rad

Fetching bob

$ git branch --remotes

  bob/master

  rad/master

```

✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi..

✓ Forking under z6Mkt67…v4N1tRk..

✓ Creating checkout in ./heartwood..

✓ Repository successfully cloned under [..]/heartwood/

```

```

$ git branch --remotes

  rad/master

```

The first branch is ours, and the second points to the repository delegate.

```

$ git remote -v

rad	rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji (fetch)

rad	rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk (push)

```

Let's check the last commit!

``` (fail)

$ rad self

✗ Hint: To setup your radicle profile, run `rad auth`.

```

```

```

$ rad patch --merged

```

We can verify that the remote tracking branches were also deleted:

```

$ rad remote add did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk

```

```

$ rad self

DID             did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

└╴Node ID (NID) z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

SSH             not running

├╴Key (hash)    SHA256:UIedaL6Cxm6OUErh9GQUzzglSk7VpQlVTI1TAFB/HWA

└╴Key (full)    ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIHahWSBEpuT1ESZbynOmBNkLBSnR32Ar4woZqSV2YNH1

Home            [..]/home/alice/.radicle

├╴Storage       [..]/home/alice/.radicle/storage

├╴Keys          [..]/home/alice/.radicle/keys

└╴Node          [..]/home/alice/.radicle/node

│ ● opened by bob (z6Mkt67…v4N1tRk) [   ...    ]                               │

│ ↑ updated to 3530243d46a2e7a8e4eac7afcbb17cc7c56b3d29 (27857ec) [   ...    ] │

│ ↑ updated to 744c1f0a75b1c42833c9aa32f79cd40443925d66 (f567f69) [   ...    ] │

╰──────────────────────────────────────────────────────────────────────────────╯

```

From rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji

   f2de534..f567f69  master     -> rad/master

From rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

```

Now our master branch is up to date with the maintainer's master:

```

$ git rev-parse master

f567f695d25b4e8fb63b5f5ad2a584529826e908

```

#![allow(clippy::or_fun_call)]

use std::ffi::OsString;

use anyhow::anyhow;

use radicle::crypto::ssh;

use radicle::crypto::ssh::Passphrase;

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

use radicle::{profile, Profile};

Options

    --stdin                 Read passphrase from stdin (default: false)

    --help                  Print help

"#,

#[derive(Debug)]

pub struct Options {

    pub stdin: bool,

}

impl Args for Options {

        use lexopt::prelude::*;

        let mut stdin = false;

        let mut parser = lexopt::Parser::from_args(args);

        while let Some(arg) = parser.next()? {

            match arg {

                Long("stdin") => {

                    stdin = true;

                }

            }

        }

    }

}

        anyhow::bail!("Error retrieving git version; please check your installation");

    }

    let home = profile::home()?;

    let passphrase = if options.stdin {

        term::passphrase_stdin()

        term::passphrase_confirm("Enter a passphrase:", RAD_PASSPHRASE)

    }?;

    let spinner = term::spinner("Creating your Ed25519 keypair...");

    spinner.finish();

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

    remote_name: Option<git::RefString>,

    aliases: &impl AliasStore,

) -> anyhow::Result<()> {

    } else {

    };

    let (remote, branch) = setup.run(remote_name, *remote_id)?;

    let name = options.name.unwrap_or_else(|| {

        let default = path.file_name().map(|f| f.to_string_lossy().to_string());

    });

    let description = options

        .description

    let branch = options.branch.unwrap_or_else(|| {

        if interactive.yes() {

        } else {

            head

        }

        ]);

    }

    table.print();

    Ok(())

}

            term::format::highlight(Did::from(id).to_string()),

            match alias {

                None => term::format::secondary(String::from("n/a")),

            },

            term::format::secondary(policy.to_string()),

        ]);

/// Patch row.

pub fn row(

    profile: &Profile,

    id: &PatchId,

    patch: &Patch,

    repository: &Repository,

Options

    --nid                Show your Node ID (NID)

    --did                Show your DID

    --home               Show your Radicle home

#[derive(Debug)]

enum Show {

    NodeId,

    Did,

    Home,

        while let Some(arg) = parser.next()? {

            match arg {

                Long("nid") if show.is_none() => {

                    show = Some(Show::NodeId);

                }

    let profile = ctx.profile()?;

    match options.show {

        Show::NodeId => {

            term::print(profile.id());

        }

fn all(profile: &Profile) -> anyhow::Result<()> {

    let mut table = term::Table::default();

    let did = profile.did();

    table.push([

        term::format::style("DID").to_string(),

        term::format::tertiary(home.display()).to_string(),

    ]);

    let storage_path = profile.home.storage();

    table.push([

        term::format::style("├╴Storage").to_string(),

                }

                (Long("alias"), Some(Operation::TrackNode { alias, .. })) => {

                    let name = parser.value()?;

                    *alias = Some(name.to_owned());

                }

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

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

    match Profile::load() {

        Ok(profile) => Ok(profile),

    }

}

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

use radicle::crypto;

use radicle::git::RefString;

use radicle::prelude::{Did, Id, NodeId};

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

    val.to_string_lossy().to_string()

}

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))

pub use radicle_term::{style, Paint};

use radicle::cob::{ObjectId, Timestamp};

use radicle::prelude::Did;

use radicle::profile::Profile;

use radicle_term::element::Line;

pub enum Author<'a> {

    Author {

        nid: &'a NodeId,

    },

    Me {

    },

}

impl<'a> Author<'a> {

        if nid == me.id() {

            Self::Me { alias }

        } else {

use std::{env, fs, thread, time};

use radicle::git;

use radicle::node::Handle as _;

use radicle::prelude::Id;

use radicle::profile::Home;

        .env("EDITOR", "true")

        .env("TZ", "UTC")

        .env("LANG", "C")

        .env(radicle_cob::git::RAD_COMMIT_TIME, "1671125284")

        .envs(git::env::GIT_DEFAULT_CONFIG)

        .envs(envs)

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

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

    fixtures::repository(working.path().join("alice"));

#[test]

fn rad_track() {

    let mut environment = Environment::new();

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

    test(

        "examples/rad-track.md",

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    // Setup a test project.

    let acme = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    // Prevent Alice from fetching Bob's fork, as we're not testing that and it may cause errors.

    alice.handle.track_repo(acme, Scope::Trusted).unwrap();

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    // Setup a test project.

    let acme = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    alice.handle.track_repo(acme, Scope::All).unwrap();

    bob.connect(&alice).converge([&alice]);

#[test]

fn rad_self() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    test("examples/rad-self.md", working, Some(&alice.home), []).unwrap();

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    test(

        "examples/rad-clone-unknown.md",

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    bob.connect(&alice);

fn rad_fetch() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    alice.connect(&bob);

    fixtures::repository(working.join("alice"));

fn rad_fork() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    alice.connect(&bob);

    fixtures::repository(working.join("alice"));

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let rid = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    let seeds = alice.handle.seeds(rid).unwrap();

    assert!(!seeds.has_connections());

    let mut environment = Environment::new();

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

    let rid = alice.project("heartwood", "");

    let events = alice.handle.events();

    alice.handle.track_node(bob.id, None).unwrap();

fn test_cob_deletion() {

    let mut environment = Environment::new();

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

    let rid = alice.project("heartwood", "");

    alice.handle.track_repo(rid, Scope::All).unwrap();

    bob.handle.track_repo(rid, Scope::All).unwrap();

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let acme = Id::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

    fixtures::repository(working.join("acme"));

    )

    .unwrap();

    bob.handle.track_repo(acme, Scope::All).unwrap();

    eve.handle.track_repo(acme, Scope::All).unwrap();

//

fn test_replication_via_seed() {

    let mut environment = Environment::new();

        policy: Policy::Track,

        scope: Scope::All,

    });

    alice.connect(&seed);

    bob.connect(&seed);

#[test]

fn rad_remote() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let home = alice.home.clone();

    let rid = Id::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

    )

    .unwrap();

    alice

        .handle

        .unwrap();

    bob.connect(&alice);

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    fixtures::repository(working.join("alice"));

    )

    .unwrap();

    test(

        "examples/rad-merge-via-push.md",

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    fixtures::repository(working.join("alice"));

    )

    .unwrap();

    bob.connect(&alice).converge([&alice]);

#[test]

fn rad_workflow() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    fixtures::repository(working.join("alice"));

    )

    .unwrap();

    bob.connect(&alice).converge([&alice]);

use radicle::cob::thread::CommentId;

use radicle::cob::{ActorId, Author, Reaction, Timestamp};

use radicle::git::RefString;

use radicle::prelude::NodeId;

use radicle::storage::{git, refs, ReadRepository};

use radicle_surf::blob::Blob;

}

/// Returns JSON for an `author` and fills in `alias` when present.

    match alias {

        Some(alias) => json!({

            "id": author.id,

}

/// Returns JSON for a patch `Merge` and fills in `alias` when present.

    match alias {

        Some(alias) => json!({

            "author": {

}

/// Returns JSON for a patch `Review` and fills in `alias` when present.

    match alias {

        Some(alias) => json!({

            "author": {

use radicle::crypto::ssh::Keystore;

use radicle::crypto::{KeyPair, Seed, Signer};

use radicle::git::{raw as git2, RefString};

use radicle::node::address as AddressStore;

use radicle::node::routing as RoutingStore;

use radicle::node::tracking::store as TrackingStore;

use radicle::profile::Home;

use radicle::storage::ReadStorage;

use radicle::Storage;

        storage,

        keystore,

        public_key: keypair.pk.into(),

    }

}

use crate::identity::Id;

use crate::node::NodeId;

use crate::runtime;

use crate::runtime::thread;

                [node, alias] => (node.as_str(), Some(alias.to_owned())),

                _ => return Err(CommandError::InvalidCommandArgs(cmd.args)),

            };

            let nid = node

                .parse()

                .map_err(|e| CommandError::InvalidCommandArg(node.to_owned(), Box::new(e)))?;

        assert!(handle.untrack_repo(proj).unwrap());

        assert!(!handle.untrack_repo(proj).unwrap());

        assert!(handle.untrack_node(peer).unwrap());

        assert!(!handle.untrack_node(peer).unwrap());

    }

use cyphernet::addr::PeerAddr;

use localtime::LocalDuration;

use radicle::prelude::Signer;

use radicle::profile;

use radicle_node::crypto::ssh::keystore::{Keystore, MemorySigner};

use radicle_node::prelude::{Address, NodeId};

use radicle_node::Runtime;

use radicle_node::{logger, service, signals};

use radicle_term as term;

Options

    --connect            <peer>         Connect to the given peer address on start

    --external-address   <address>      Publicly accessible address (default 0.0.0.0:8776)

    --git-daemon         <address>      Address to bind git-daemon to (default 0.0.0.0:9418)

#[derive(Debug)]

struct Options {

    daemon: Option<net::SocketAddr>,

    listen: Vec<net::SocketAddr>,

    force: bool,

}

impl Options {

        use lexopt::prelude::*;

        let mut parser = lexopt::Parser::from_env();

        let mut listen = Vec::new();

        let mut daemon = None;

        let mut force = false;

        while let Some(arg) = parser.next()? {

            match arg {

                Long("connect") => {

                    let peer: PeerAddr<NodeId, Address> = parser.value()?.parse()?;

                }

                Long("external-address") => {

                    let addr = parser.value()?.parse()?;

                }

                Long("force") => {

                    force = true;

                        .value()?

                        .parse()

                        .map_err(|s| anyhow!("unknown tracking policy {:?}", s))?;

                }

                Long("tracking-scope") => {

                    let scope = parser

                        .value()?

                        .parse()

                        .map_err(|s| anyhow!("unknown tracking scope {:?}", s))?;

                }

                Long("limit-routing-max-age") => {

                    let secs: u64 = parser.value()?.parse()?;

                }

                Long("limit-routing-max-size") => {

                }

                Long("limit-fetch-concurrency") => {

                }

                Long("listen") => {

                    let addr = parser.value()?.parse()?;

            }

        }

            anyhow::bail!(

                "external address limit ({}) exceeded",

                service::ADDRESS_LIMIT,

        }

        Ok(Self {

            daemon,

            force,

            listen,

        })

    }

}

fn execute() -> anyhow::Result<()> {

    logger::init(log::Level::Debug)?;

    log::info!(target: "node", "Starting node..");

    log::info!(target: "node", "Version {} ({})", env!("CARGO_PKG_VERSION"), env!("GIT_HEAD"));

    let home = profile::home()?;

    let passphrase = term::io::passphrase(profile::env::RAD_PASSPHRASE)

        .context(format!("`{}` must be set", profile::env::RAD_PASSPHRASE))?;

    let keystore = Keystore::new(&home.keys());

    log::info!(target: "node", "Node ID is {}", signer.public_key());

    let proxy = net::SocketAddr::new(net::Ipv4Addr::LOCALHOST.into(), 9050);

    let daemon = options.daemon.unwrap_or_else(|| {

        net::SocketAddr::new(net::Ipv4Addr::LOCALHOST.into(), radicle::git::PROTOCOL_PORT)

            .ok()

            .and_then(|ann| NodeAnnouncement::decode(&mut ann.as_slice()).ok())

            .and_then(|ann| {

                    Some(ann)

                } else {

                    None

            );

            ann

        } else {

                .solve(Default::default())

                .expect("Runtime::init: unable to solve proof-of-work puzzle")

        };

use thiserror::Error;

use crate::identity::Id;

use crate::profile::Home;

use crate::runtime::Emitter;

use crate::service;

        receiver.recv().map_err(Error::from)

    }

        let (sender, receiver) = chan::bounded(1);

        self.command(service::Command::TrackNode(id, alias, sender))?;

        receiver.recv().map_err(Error::from)

#![allow(clippy::too_many_arguments)]

#![allow(clippy::collapsible_match)]

#![allow(clippy::collapsible_if)]

pub mod filter;

pub mod io;

pub mod message;

use crate::identity::{Doc, Id};

use crate::node::routing;

use crate::node::routing::InsertResult;

use crate::prelude::*;

use crate::runtime::Emitter;

use crate::service::message::{Announcement, AnnouncementMessage, Ping};

use crate::Link;

pub use crate::node::events::{Event, Events};

pub use crate::service::message::{Message, ZeroBytes};

pub use crate::service::session::Session;

    /// Untrack the given repository.

    UntrackRepo(Id, chan::Sender<bool>),

    /// Track the given node.

    /// Untrack the given node.

    UntrackNode(NodeId, chan::Sender<bool>),

    /// Query the internal service state.

        // Connect to configured peers.

        let addrs = self.config.connect.clone();

            self.connect(id, addr);

        }

        // Ensure that our inventory is recorded in our routing table, and we are tracking

            .insert(

                &self.node_id(),

                self.node.features,

                self.node.work(),

                self.node.timestamp,

                self.node

                    return Ok(false);

                }

                // If this node isn't a seed, we're not interested in adding it

                // to our address book, but other nodes may be, so we relay the message anyway.

                if !features.has(Features::SEED) {

                match self.addresses.insert(

                    announcer,

                    *features,

                    ann.work(),

                    timestamp,

                    addresses

    }

}

    use super::*;

    use crate::service::filter::Filter;

        ]

    }

    pub fn inventory(timestamp: Timestamp, inventory: Vec<Id>) -> InventoryAnnouncement {

        type Inventory = BoundedVec<Id, INVENTORY_LIMIT>;

use crate::crypto;

use crate::crypto::Unverified;

use crate::identity::Id;

use crate::node;

use crate::prelude::BoundedVec;

use crate::service::filter::Filter;

use crate::service::{Link, NodeId, Timestamp};

    pub features: node::Features,

    /// Monotonic timestamp.

    pub timestamp: Timestamp,

    /// Announced addresses.

    pub addresses: BoundedVec<Address, ADDRESS_LIMIT>,

    /// Nonce used for announcement proof-of-work.

        }

        Some(self)

    }

}

impl wire::Encode for NodeAnnouncement {

        let ann = NodeAnnouncement {

            features: node::Features::SEED,

            timestamp: 42491841,

            addresses: BoundedVec::new(),

            nonce: 0,

        };

        assert_eq!(ann.work(), 0);

        assert_eq!(ann.clone().solve(1).unwrap().work(), 4);

        assert_eq!(ann.clone().solve(8).unwrap().work(), 9);

    }

}

use std::collections::{HashSet, VecDeque};

use std::fmt;

use crate::service::message;

use crate::service::message::Message;

use crate::service::{Address, Id, LocalTime, NodeId, Outbox, Rng};

use qcheck::Arbitrary;

use crate::crypto;

use crate::prelude::{BoundedVec, Id, NodeId, Timestamp};

use crate::service::filter::{Filter, FILTER_SIZE_L, FILTER_SIZE_M, FILTER_SIZE_S};

use crate::service::message::{

                let message = NodeAnnouncement {

                    features: u64::arbitrary(g).into(),

                    timestamp: Timestamp::arbitrary(g),

                    addresses: Arbitrary::arbitrary(g),

                    nonce: u64::arbitrary(g),

                }

use std::io::BufRead as _;

use std::mem::ManuallyDrop;

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

use std::{

    collections::{BTreeMap, BTreeSet},

    env, fs, io, iter, net, process, thread, time,

use radicle::node::routing::Store;

use radicle::node::tracking::store as TrackingStore;

use radicle::node::Handle as _;

use radicle::profile::Home;

use radicle::profile::Profile;

use radicle::rad;

    /// Create a new node in this environment. This should be used when a running node

    /// is required. Use [`Environment::profile`] otherwise.

        let signer = MemorySigner::load(&profile.keystore, "radicle".to_owned().into()).unwrap();

        let tracking_db = profile.home.node().join(TRACKING_DB_FILE);

        TrackingStore::Config::open(tracking_db).unwrap();

        Node {

            id: *profile.id(),

            home: profile.home,

            signer,

            storage: profile.storage,

        }

    /// Create a new profile in this environment.

    /// This should be used when a running node is not required.

        let storage = Storage::open(home.storage()).unwrap();

        let keystore = Keystore::new(&home.keys());

        let keypair = KeyPair::from_seed(Seed::from([!(self.users as u8); 32]));

        let tracking_db = home.node().join(TRACKING_DB_FILE);

        TrackingStore::Config::open(tracking_db).unwrap();

        let addresses_db = home.node().join(ADDRESS_DB_FILE);

        Book::open(addresses_db).unwrap();

            storage,

            keystore,

            public_key: keypair.pk.into(),

        }

    }

}

    pub home: Home,

    pub signer: G,

    pub storage: Storage,

}

/// Handle to a running node.

impl Node<MockSigner> {

    /// Create a new node.

        let home = base.join(

            iter::repeat_with(fastrand::alphanumeric)

                .take(8)

            home,

            signer,

            storage,

        }

    }

}

impl<G: cyphernet::Ecdh<Pk = NodeId> + Signer + Clone> Node<G> {

    /// Spawn a node in its own thread.

        let listen = vec![([0, 0, 0, 0], 0).into()];

        let proxy = net::SocketAddr::new(net::Ipv4Addr::LOCALHOST.into(), 9050);

        let daemon: net::SocketAddr = {

        let (_, signals) = chan::bounded(1);

        let rt = Runtime::init(

            self.home.clone(),

            listen,

            proxy,

            daemon,

use std::{io, time};

use crate::identity::Id;

use crate::runtime::HandleError;

use crate::service::tracking;

use crate::service::NodeId;

        Ok(self.tracking_repos.lock().unwrap().remove(&id))

    }