offline-cli 0.4.0

The Offline Protocol developer CLI
//! `offline setup`: provision org, application, and default API key.

use anyhow::Result;
use clap::Args;
use serde_json::json;

use crate::commands::provision::{email_login_required, ensure_provisioned, ProvisionOptions};
use crate::config::CliConfig;
use crate::output;

const DEFAULT_APP_NAME: &str = "My Offline App";

#[derive(Args)]
pub struct SetupArgs {
    /// Application to use: an existing one with this name, or a new one.
    /// Without it, the configured application (or the organization's first)
    /// is used, and `My Offline App` is created when there is none.
    #[arg(long)]
    pub app_name: Option<String>,
    /// Organization name when creating a new organization
    #[arg(long)]
    pub org_name: Option<String>,
    /// API key alias
    #[arg(long, default_value = "CLI default")]
    pub key_alias: String,
    /// Key product scope: all | offline_id | mesh_sdk | proof_of_location
    #[arg(long, default_value = "all")]
    pub product: String,
    #[arg(long)]
    pub json: bool,
}

pub async fn run(args: SetupArgs) -> Result<()> {
    let mut config = CliConfig::load()?;
    crate::commands::provision::ensure_logged_in_for_provision(&config, !args.json).await?;
    config = CliConfig::load()?;
    if !config.has_api_credentials() && config.effective_access_token().is_none() {
        return Err(email_login_required("`offline setup`", &config));
    }

    ensure_provisioned(
        &mut config,
        ProvisionOptions {
            app_name: args.app_name.as_deref().unwrap_or(DEFAULT_APP_NAME),
            select_app_by_name: args.app_name.is_some(),
            org_name: args.org_name.as_deref(),
            key_alias: Some(&args.key_alias),
            product: &args.product,
        },
    )
    .await?;

    if args.json {
        output::json(&json!({
            "orgId": config.org_id,
            "appId": config.app_id,
            "email": config.email,
            "hasApiKey": config.effective_api_key().is_some(),
        }))?;
    } else {
        output::success("Offline Protocol account is ready for CLI use");
        if let Some(org_id) = &config.org_id {
            output::note(&format!("organization: {org_id}"));
        }
        if let Some(app_id) = &config.app_id {
            output::note(&format!("application: {app_id}"));
        }
        output::note("Run `offline create` to scaffold an app, or `offline whoami --verify` to check credentials");
    }
    Ok(())
}

pub async fn setup_for_create(
    config: &mut CliConfig,
    app_name: &str,
    mesh_enabled: bool,
    pol_enabled: bool,
    interactive: bool,
) -> Result<()> {
    if config.has_api_credentials() {
        return Ok(());
    }
    crate::commands::provision::ensure_logged_in_for_provision(config, interactive).await?;
    let config_reloaded = CliConfig::load()?;
    *config = config_reloaded;
    ensure_provisioned(
        config,
        ProvisionOptions {
            app_name,
            select_app_by_name: false,
            org_name: None,
            key_alias: Some("CLI default"),
            product: crate::commands::provision::product_for_create(mesh_enabled, pol_enabled),
        },
    )
    .await
}