pub fn clone(id: Id, _interactive: Interactive, ctx: impl term::Context) -> anyhow::Result<()> {

    let profile = ctx.profile()?;

    let signer = term::signer(&profile)?;

    // Track & fetch project.

    let storage = &profile.storage;

    let (_, rid) = radicle::rad::cwd().context("this command must be run within a project")?;

    let project = storage.repository(rid)?.project_of(profile.id())?;

    term::info!(

        "Establishing 🌱 tracking relationship for {}",

}

pub fn untrack(id: Id, profile: &Profile) -> anyhow::Result<bool> {

    node.untrack_repo(id).map_err(|e| anyhow!(e))

}

    let base = Path::new(env!("CARGO_MANIFEST_DIR"));

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

    let home = if let Some(profile) = profile {

    } else {

        tmp.path().to_path_buf()

    };

        Ok(self.sign(msg))

    }

}

    tracing::info!("{}", str::from_utf8(&git_version)?.trim());

    let profile = Arc::new(radicle::Profile::load()?);

    let git_router = Router::new()

        .route("/:project/*request", any(git_handler))

use cyphernet::{Cert, EcSign};

use netservices::resource::NetAccept;

use reactor::poller::popol;

use reactor::Reactor;

use thiserror::Error;

use crate::service::{routing, tracking};

use crate::wire::Wire;

use crate::worker::{WorkerPool, WorkerReq};

pub mod handle;

use handle::Handle;

    ///

    /// This function spawns threads.

    pub fn with(

        config: service::Config,

        listen: Vec<net::SocketAddr>,

        proxy: net::SocketAddr,

        signer: G,

    ) -> Result<Runtime<G>, Error> {

        let network = config.network;

        let rng = fastrand::Rng::new();

        let clock = LocalTime::now();

        let address_db = node_dir.join(ADDRESS_DB_FILE);

        let routing_db = node_dir.join(ROUTING_DB_FILE);

        let tracking_db = node_dir.join(TRACKING_DB_FILE);

        let handle = Handle::from(reactor.controller());

        let control = thread::spawn({

            let handle = handle.clone();

        });

        let controller = reactor.controller();

        let mut local_addrs = Vec::new();

use radicle::profile;

use radicle_node::client::Runtime;

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

use radicle_node::{logger, service};

#[derive(Debug)]

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

    let options = Options::from_env()?;

    let passphrase = env::var(profile::env::RAD_PASSPHRASE)

        .context("`RAD_PASSPHRASE` is required to be set for the node to establish connections")?

        .into();

    let config = service::Config {

        connect: options.connect.into_iter().collect(),

        external_addresses: options.external_addresses,

        ..service::Config::default()

    };

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

    runtime.run()?;

    time::Duration,

};

use radicle::git::refname;

use radicle::identity::Id;

use radicle::node::Handle;

use radicle::storage::WriteStorage;

use radicle::test::fixtures;

use radicle::Storage;

use radicle::{assert_matches, rad};

struct Node {

    id: NodeId,

    addr: net::SocketAddr,

    storage: Storage,

    #[allow(dead_code)]

    thread: thread::JoinHandle<Result<(), client::Error>>,

                .take(8)

                .collect::<String>(),

        );

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

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

        let addr = *rt.local_addrs.first().unwrap();

        let id = rt.id;

        let handle = rt.handle.clone();

                        // Connect to local node and announce refs to the network.

                        // If our node is not running, we simply skip this step, as the

                        // refs will be announced eventually, when the node restarts.

                            conn.announce_refs(url.repo)?;

                        }

                    }

    };

    println!("id: {}", profile.id());

    Ok(())

}

    if let Some(id) = env::args().nth(1) {

        let id = Id::from_str(&id)?;

        let repo = radicle::rad::clone(id, &cwd, &signer, &profile.storage, &mut node)?;

        println!(

    let sigrefs = project.sign_refs(&signer)?;

    let head = project.set_head()?;

    println!("head: {}", head);

    println!("ok: {}", sigrefs.signature);

        "fingerprint: {}",

        radicle::crypto::ssh::fmt::fingerprint(profile.id())

    );

    Ok(())

}

#[derive(Debug, Clone)]

pub struct Profile {

    pub storage: Storage,

    pub keystore: Keystore,

    pub public_key: PublicKey,

impl Profile {

    pub fn init(home: impl AsRef<Path>, passphrase: impl Into<Passphrase>) -> Result<Self, Error> {

        let home = home.as_ref().to_path_buf();

        let storage = Storage::open(paths.storage())?;

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

        let public_key = keystore.init("radicle", passphrase)?;

        transport::local::register(storage.clone());

        Ok(Profile {

            storage,

            keystore,

            public_key,

    pub fn load() -> Result<Self, Error> {

        let home = self::home()?;

        let public_key = keystore

            .public_key()?

        transport::local::register(storage.clone());

        Ok(Profile {

            storage,

            keystore,

            public_key,

    /// Return the path to the keys folder.

    pub fn keys(&self) -> PathBuf {

    }

    /// Get the path to the radicle node socket.

    }

    /// Get `Paths` of profile

    }

}

}

#[derive(Debug, Clone)]

}

    }

    pub fn storage(&self) -> PathBuf {

    pub fn node(&self) -> PathBuf {

        self.home.join("node")

    }

}