SubCommand::Git(git) => git.run(),

        SubCommand::Git(git) => git.run().await,

                    h?.1.0.into()

                    h?.1 .0.into()

    pub fn run(self) -> Result<(), anyhow::Error> {

    pub async fn run(self) -> Result<(), anyhow::Error> {

        import(&git, &mut env_git, &mut repo, &dag)?;

        import(&git, &mut env_git, &mut repo, &dag).await?;

fn import(

async fn import(

    let all_identities = pijul_identity::Complete::load_all().unwrap();

                let state = import_commit(git, repo, &txn, &channel, &oid, &mut stats)?;

                let state =
                    import_commit(git, repo, &txn, &channel, &oid, &mut stats, &all_identities)
                        .await?;

fn import_commit<T: TxnTExt + MutTxnTExt + GraphIter + Send + Sync + 'static>(

async fn import_commit<T: TxnTExt + MutTxnTExt + GraphIter + Send + Sync + 'static>(

    all_identities: &[pijul_identity::Complete],

    let email = signature.email().unwrap().to_string();
    let identity = if email.is_empty() {
        None
    } else {
        all_identities
            .iter()
            .find(|i| i.config.author.email == email)
    };
    if let Some(identity) = identity {
        author.insert("key".to_string(), identity.public_key.key.clone());
    };
    author.insert("email".to_string(), email);

        identity,

    );

    )
    .await;

fn record_apply<

async fn record_apply<

    identity: Option<&pijul_identity::Complete>,

        .save_change(&mut change, |_, _| Ok::<_, anyhow::Error>(()))

        .save_change(&mut change, |change, hash| {
            if let Some(identity) = identity {
                let secret = identity.decrypt().unwrap().0;
                change.unhashed = Some(serde_json::json!({
                    "signature": secret.sign_raw(&hash.to_bytes()).unwrap(),
                }));
            }
            Ok::<_, anyhow::Error>(())
        })

    author.insert("email".to_string(), signature.email().unwrap().to_string());