ordinary 0.13.0

Ordinary CLI
Documentation
// Copyright (C) 2026 The Ordinary Authors.
//
// SPDX-License-Identifier: BSD-3-Clause

use crate::HostCallFlags;
use crate::cmds::accounts::get_current_account;
use anyhow::bail;
use clap::Subcommand;
use ordinary_config::{FfiVersion, LanguageToolchain, OrdinaryHostConfig};
use saferlmdb::Environment;
use std::path::Path;
use std::sync::Arc;
use tracing::instrument;

#[derive(Subcommand, Debug)]
pub enum Extensions {
    /// add a new extension to your Ordinary host
    #[clap(visible_aliases(["create", "new"]))]
    Add {
        /// extension name
        name: String,
        /// language the extension runs
        #[arg(short, long, default_value = "rust")]
        toolchain: LanguageToolchain,
    },
    /// build just the extensions
    Build {
        /// name of a specific extension to build (optional).
        /// will install all when the `--name` flag is not passed.
        #[arg(short, long)]
        name: Option<String>,
        /// build extensions without checking the cache
        #[arg(short, long, default_value_t = false)]
        force: bool,
    },
    /// upload extensions to Ordinary host
    Upload {
        #[command(flatten)]
        host: HostCallFlags,

        /// name of a specific extension to upload (optional).
        /// will upload all when the `--name` flag is not passed.
        #[arg(short, long)]
        name: Option<String>,
    },
}

impl Extensions {
    #[instrument(skip_all, name = "extensions")]
    pub async fn handle(&self, project: &str, env: &Arc<Environment>) -> anyhow::Result<()> {
        match self {
            Self::Add { name, toolchain } => {
                ordinary_extension::modify::add(Path::new(project), name, toolchain)?;
            }
            Self::Build { name, force } => {
                let env_file = Path::new(project).join(".env");
                if env_file.exists() {
                    dotenvy::from_path(env_file)?;
                }

                let config = OrdinaryHostConfig::get(project, true)?;
                config.validate()?;

                if let Some(name) = name {
                    if let Some(extension_config) = config
                        .extensions
                        .iter()
                        .find(|e| e.name_validated() == name)
                    {
                        match extension_config.ffi_validated().version {
                            FfiVersion::V1 => {
                                ordinary_extension::build::v1::build(
                                    extension_config,
                                    Path::new(project),
                                    *force,
                                )?;
                            }
                        }
                    } else {
                        bail!("extension with name '{name}' doesn't exist");
                    }
                } else {
                    for extension_config in &config.extensions {
                        match extension_config.ffi_validated().version {
                            FfiVersion::V1 => {
                                ordinary_extension::build::v1::build(
                                    extension_config,
                                    Path::new(project),
                                    *force,
                                )?;
                            }
                        }
                    }
                }
            }
            Self::Upload { host, name } => {
                let account = get_current_account()?;
                let client = host.client(&account, env)?;

                if let Some(name) = name {
                    client.extensions_upload(project, name).await?;
                } else {
                    client.extensions_upload_all(project).await?;
                }
            }
        }

        Ok(())
    }
}