Method execute

atomic-cli/src/commands/intent/verify.rs:78–156

(&self)

impl IntentVerify {
    async fn execute(&self) -> CliResult<()> {
        let root = find_repository_root()?;
        let repo = Repository::open(&root).map_err(CliError::Repository)?;

        let inputs = bridge::read_intent(&repo, &self.id)?;
        let node = match bridge::load_attestation(&repo, &self.id, &inputs)? {
            bridge::Attestation::None => {
                return Err(CliError::InvalidArgument {
                    message: format!(
                        "no attestation found for {}; run `atomic intent attest {}` first",
                        self.id, self.id
                    ),
                })
            }
            bridge::Attestation::Stale(_) => {
                return Err(CliError::InvalidArgument {
                    message: format!(
                        "the attestation for {} is stale (the intent changed since it was \
                         signed); re-run `atomic intent attest {}`",
                        self.id, self.id
                    ),
                })
            }
            bridge::Attestation::Fresh(node) => *node,
        };

        // Resolve the public key to verify against. Local store first; when
        // `--identity <name>` is given but not present locally, fall back to
        // the configured storage server.
        let store = IdentityStore::open_default().map_err(|e| {
            CliError::Internal(anyhow::anyhow!("Failed to open identity store: {e}"))
        })?;

        let (public_key, source) = if let Some(name) = &self.identity {
            match store.load_by_name(name) {
                Ok(identity) => {
                    let did = identity.id.to_base32();
                    (
                        identity.public_key,
                        source_line(name, &did, "local identity store"),
                    )
                }
                Err(_) => {
                    let resolved = self.resolve_remote(name, &node).await?;
                    (resolved.key, resolved.source)
                }
            }
        } else {
            let identity = store
                .get_default()
                .map_err(|e| {
                    CliError::Internal(anyhow::anyhow!("Failed to load default identity: {e}"))
                })?
                .ok_or_else(|| CliError::InvalidArgument {
                    message: "No default identity set. Create one first:\n  \
                              atomic identity new <name> --email <email> --set-default"
                        .to_string(),
                })?;