The `Service` has now learned to return results when an error occurs which

  will be reported back to the user.

- Parsing addresses involving an IPv6 host failed if they were enclosed in

  Also, ambiguous addresses would parse, e.g. `::1:8776` would be

  indistinguishable from `[::1]:8776`. Since a port number is always required

  along a host when providing an address, IPv6 addresses now always require

    use std::time;

    use std::process;

Imports are organized in groups, from least specific to more specific:

obvious, eg.

    if let Some(e) = result.err() {

    }

Use 1-word names for function parameters or variables that have larger scopes:

    pub fn commit(repo: &Repository, sig: &Signature) -> Result<Commit, Error> {

    }

Use the most descriptive names for globals:

    // all of it. It can happen that inventory is not properly tracked if for eg. the

    // user creates a new repository while the node is stopped.

    for rid in self.storage.inventory()? {

### Referring to radicle.xyz in Code

Initializing your Radicle 👾 identity

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

✓ You're all set.

```

$ rad id update --title "Allow Bob & Eve" --allow did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk --allow did:key:z6Mkux1aUQD2voWWukVb5nNUR7thrHveQG4pDQua8nVhib7Z -q

$ rad inspect --identity

{

  "payload": {

```

$ rad id update --title "Remove allow list" --disallow did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk --disallow did:key:z6Mkux1aUQD2voWWukVb5nNUR7thrHveQG4pDQua8nVhib7Z

$ rad inspect --identity

{

  "payload": {

```

$ rad id update --title "Allow Bob" --allow did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk -q

```

```

$ rad id update --title "Allow Bob" --allow did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk

```

$ rad id update --title "IPO" --visibility public -q

```

Now, if we attempt to change the `allow` list we also get an error with a

    +   "did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi",

    +   "did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk"

      ],

    -  "threshold": 1

    +  "threshold": 2

``` ~bob

$ cd heartwood

✓ Synced with 1 seed(s)

$ git commit -m "Change copyright" --allow-empty -q

$ git push rad HEAD:bob/copy

│ Author  bob z6Mkt67…v4N1tRk                      │

│ Status  open                                     │

│                                                  │

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

```

```

$ 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

``` ~alice

$ rad id update --title "Allow Bob" --description "" --allow did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk -q

$ rad inspect --identity

{

  "payload": {

``` ~alice

$ rad id update --title "Allow Bob" --description "" --allow did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk -q

$ rad sync --announce --timeout 3s

✓ Synced with 1 seed(s)

```

```

$ git remote add origin file://$PWD/remote

$ git push -u origin master:master

$ git branch -vv

* master f2de534 [origin/master] Second commit

```

```

$ rad node stop

```

Note that if we unseed a repository, it is no longer part of our inventory:

```

``` (fail)

$ rad node connect z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk@radicle.xyz:8776

✗ Error: failed to open node control socket "[..]/.radicle/node/control.sock" (entity not found)

✗ Hint: to start your node, run `rad node start`.

```

``` ~bob (fail)

$ rad patch checkout aa45913 --name alice-init

✗ Error: branch 'alice-init' already exists (use `--force` to overwrite)

```

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

    };

    let passphrase = passphrase.filter(|passphrase| !passphrase.trim().is_empty());

    let profile = Profile::init(home, alias, passphrase.clone(), env::seed())?;

    let mut agent = true;

    spinner.finish();

    if let Some(passphrase) = passphrase {

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

            Ok(mut agent) => {

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

                    spinner.finish();

                } else {

        anyhow::bail!("the local path {:?} already exists", path.as_path());

    }

    let repo = match radicle::rad::checkout(args.repo, &remote, path.clone(), &storage, false) {

        Ok(repo) => repo,

        Err(err) => {

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

    let mut node = radicle::Node::new(profile.socket_from_env());

    let mut push_cmd = String::from("git push");

    match radicle::rad::init(

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

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

        term::headline(format!(

            term::format::tertiary(key)

        ));

        true

}

pub fn stop(node: Node, profile: &Profile) {

    if node.shutdown().is_err() {

        spinner.error("node is not running");

    } else {

    timeout: time::Duration,

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

    let spinner = term::spinner(format!(

        term::format::node_id_human_compact(&nid)

    ));

    match node.connect(

    addrs: Vec<Address>,

    timeout: time::Duration,

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

    let mut errors = HashMap::new();

    for addr in addrs {

        spinner.message(format!(

            term::format::node_id_human_compact(&nid)

        ));

        match node.connect(

        None => patch.latest(),

    };

    let patch_branch = opts.branch(patch_id)?;

    let commit = match working.find_branch(patch_branch.as_str(), git::raw::BranchType::Local) {

[group('pre-push')]

[group('check')]

[parallel]

    @echo "{{CHECK}}Checking for spelling typos...{{NORMAL}}"

    @typos

# Run codespell

[group('pre-commit')]

[group('pre-push')]

- [ ] Flexibility to define network topologies.

- [ ] Easy to construct and run new simulations.

- [ ] Reproducible starting state.

## Plan