silicon-iam-cli 1.2.0

Command-line client for Silicon IAM, built on the silicon-iam-client crate.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! The Silicon IAM command-line client.
//!
//! A thin, stateful shell over `silicon-iam-client`. Everything it can do, the
//! client crate can do; what the CLI adds is memory -- which service, which
//! profile, whose session -- and a terminal to read a verification code from.

#![forbid(unsafe_code)]

mod cli;
mod commands;
mod context;
mod error;
mod experience;
mod guidance;
mod manual;
mod output;
mod store;
mod updater;

use crate::{cli::Cli, context::Context};

#[tokio::main]
async fn main() -> std::process::ExitCode {
    let (cli, path) = match experience::parse() {
        Ok(parsed) => parsed,
        Err(exit) => return exit,
    };
    let maintain_after_command = updater::follows(&cli.command);
    let exit = match run(cli).await {
        Ok(()) => std::process::ExitCode::SUCCESS,
        Err(error) => {
            let message = error.to_string();
            eprintln!("error: {message}");
            if let Some(hint) = error.hint() {
                eprintln!("hint: {hint}");
            }
            if matches!(error, error::CliError::Usage(_)) {
                experience::print_help(&path);
            } else {
                eprintln!("help: iam {} --help", path.join(" "));
            }
            // The correlation identifier makes failures actionable server-side.
            if let Some(request_id) = error.request_id()
                && !message.contains(request_id)
            {
                eprintln!("request: {request_id}");
            }
            std::process::ExitCode::from(u8::try_from(error.exit_code()).unwrap_or(1))
        }
    };
    if maintain_after_command {
        // Publish all result bytes before a registry check or Cargo install.
        use std::io::Write as _;
        let _ = std::io::stdout().flush();
        let _ = std::io::stderr().flush();
        match updater::automatic().await {
            Ok(updater::Outcome::Updated { from, to }) => {
                eprintln!(
                    "Updated iam from {from} to {to} after the command completed. The next invocation will use {to}."
                );
            }
            Ok(_) => {}
            Err(error) => eprintln!("warning: post-command automatic update skipped: {error}"),
        }
    }
    exit
}

async fn run(cli: Cli) -> error::Result<()> {
    // Reference commands must work offline, including with a broken credential
    // store or unavailable service. They never start background maintenance.
    match &cli.command {
        cli::Command::Docs { topic, search } => {
            return manual::run(cli.global.output, topic.as_deref(), search.as_deref());
        }
        cli::Command::Commands => return experience::print_commands(cli.global.output),
        _ => {}
    }
    let context = Context::new(
        cli.global.output,
        cli.global.profile,
        cli.global.url,
        cli.global.org,
        cli.global.no_org,
        cli.global.test,
        cli.global.step_up,
    )?;
    let guidance = guidance::Plan::capture(&context, &cli.command);
    match commands::dispatch(&context, cli.command).await {
        Ok(()) => {
            guidance.emit();
            Ok(())
        }
        Err(error) => {
            eprintln!(
                "Context: profile={}, service={}, environment={}, organization={}",
                context.profile_name,
                context.profile.url,
                context
                    .testing_environment_id()
                    .map_or_else(|| "production".to_owned(), |id| format!("test {id}")),
                context.organization_if_set().unwrap_or("(none)"),
            );
            Err(error)
        }
    }
}