ordinary 0.13.0

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

pub mod extensions;
pub mod secrets;

use crate::cmds::accounts::get_current_account;
use crate::cmds::host::extensions::Extensions;
use crate::cmds::host::secrets::Secrets;
use crate::cmds::logs::{Logs, Sync, print_logs_metadata_table};
use crate::{Accounts, HostCallFlags, deploy_host_local};
use anyhow::bail;
use clap::Subcommand;
use clio::ClioPath;
use ordinary_config::OrdinaryHostConfig;
use ordinaryd::{AppHost, GlobalArgs};
use saferlmdb::Environment;
use std::env::home_dir;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use tracing::instrument;

#[derive(Subcommand, Debug)]
pub enum Host {
    /// create a new Ordinary host
    #[clap(visible_aliases(["create", "init"]))]
    New {
        /// host domain
        domain: String,
        /// directory where the project will be initialized.
        ///
        /// if not passed, will create project in dir named for domain.
        #[arg(long)]
        dir: Option<PathBuf>,
    },
    /// build the Ordinary host
    Build {
        /// build extensions without checking the cache
        #[arg(short, long, default_value_t = false)]
        force: bool,

        /// project path
        #[arg(short, long, value_parser = clap::value_parser!(ClioPath).exists().is_dir(), default_value = ".")]
        project: ClioPath,
    },
    /// start the host, locally
    #[clap(visible_aliases(["run", "preview"]))]
    Start {
        #[command(flatten)]
        app_host: AppHost,

        #[command(flatten)]
        global_args: GlobalArgs,

        /// disables these defaults set for development:
        /// `--insecure`
        /// `--insecure-cookies`
        /// `--danger-dns-no-verify`
        #[arg(short, long, default_value_t = false)]
        disable_defaults: bool,
    },
    /// combines `build`, `deploy` and `extensions upload`
    Publish {
        #[command(flatten)]
        host: HostCallFlags,

        /// project path
        #[arg(short, long, value_parser = clap::value_parser!(ClioPath).exists().is_dir(), default_value = ".")]
        project: ClioPath,
    },
    /// deploy changes to `ordinaryd.json`
    Deploy {
        #[command(flatten)]
        host: HostCallFlags,

        /// project path
        #[arg(short, long, value_parser = clap::value_parser!(ClioPath).exists().is_dir(), default_value = ".")]
        project: ClioPath,

        /// deploy built artifacts to local machine.
        ///
        /// will skip all remote deployment even if remote flags are passed.
        #[arg(short, long, default_value_t = false)]
        local: bool,
    },
    /// manage extensions on your Ordinary app
    #[clap(visible_aliases(["ext", "extension"]))]
    Extensions {
        #[command(subcommand)]
        extensions: Extensions,

        /// project path
        #[arg(short, long, value_parser = clap::value_parser!(ClioPath).exists().is_dir(), default_value = ".")]
        project: ClioPath,
    },
    /// manage secrets in your Ordinary app
    Secrets {
        #[command(subcommand)]
        secrets: Secrets,

        /// project path
        #[arg(short, long, value_parser = clap::value_parser!(ClioPath).exists().is_dir(), default_value = ".")]
        project: ClioPath,
    },
    /// query system and application logs
    Logs {
        #[command(flatten)]
        host: HostCallFlags,

        #[command(subcommand)]
        logs: Logs,
    },
    /// manage accounts connected to `ordinaryd`
    #[clap(visible_aliases(["account", "accts", "acct"]))]
    Accounts {
        #[command(flatten)]
        host: HostCallFlags,

        #[command(subcommand)]
        accounts: Accounts,
    },
    /// tools for moderation
    Moderation {
        #[command(flatten)]
        host: HostCallFlags,

        #[command(subcommand)]
        moderation: Moderation,
    },
}

#[derive(Subcommand, Debug)]
pub enum Moderation {
    /// lock resources to prevent abuse
    Lock {
        /// account to be locked
        #[arg(short, long)]
        account: String,
    },
    /// unlock resources upon resolution
    Unlock {
        /// account to be unlocked
        #[arg(short, long)]
        account: String,
    },
}

impl Host {
    #[expect(clippy::missing_panics_doc, clippy::too_many_lines)]
    #[instrument(skip_all, name = "host")]
    pub async fn handle(&self, env: &Arc<Environment>) -> anyhow::Result<()> {
        match self {
            Self::New { domain, dir } => ordinary_modify::host::new(dir.as_deref(), domain)?,
            Self::Build { force, project } => {
                let project = project.to_str().expect("failed to get string from project");
                let env_file = Path::new(project).join(".env");
                if env_file.exists() {
                    dotenvy::from_path(env_file)?;
                }

                let env_file = Path::new(project).join(".env");
                if env_file.exists() {
                    dotenvy::from_path(env_file)?;
                }

                ordinary_build::host(project, *force)?;
            }
            Self::Publish { host, project } => {
                let project = project.to_str().expect("failed to get string from project");

                let env_file = Path::new(project).join(".env");
                if env_file.exists() {
                    dotenvy::from_path(env_file)?;
                }

                ordinary_build::host(project, true)?;

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

                let account = get_current_account()?;
                let client = host.client(&account, env)?;

                client.host_deploy(project).await?;

                if !config.extensions.is_empty() {
                    client.extensions_upload_all(project).await?;
                }
            }
            Self::Deploy {
                host,
                project,
                local,
            } => {
                let project = project.to_str().expect("failed to get string from project");

                if *local {
                    let data_dir = match home_dir() {
                        Some(home) => home.join(".ordinary"),
                        None => bail!("no home dir"),
                    };

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

                    deploy_host_local(data_dir, project, &config)?;
                } else {
                    let account = get_current_account()?;
                    let client = host.client(&account, env)?;

                    let env_file = Path::new(project).join(".env");
                    if env_file.exists() {
                        dotenvy::from_path(env_file)?;
                    }

                    client.host_deploy(project).await?;
                }

                tracing::info!("host deployed");
            }
            Self::Extensions {
                extensions,
                project,
            } => {
                let project = project.to_str().expect("failed to get string from project");
                extensions.handle(project, env).await?;
            }
            Self::Secrets { secrets, project } => {
                let project = project.to_str().expect("failed to get string from project");
                secrets.handle(project, env).await?;
            }
            Self::Logs { logs, host } => {
                let account = get_current_account()?;
                let client = host.client(&account, env)?;

                match logs {
                    Logs::Query {
                        query,
                        json_columns,
                        sync,
                    } => {
                        if sync == &Some(true) {
                            client.root_logs_sync(None, None).await?;
                        }

                        let res = client.root_logs_query(query, json_columns.as_ref())?;
                        print!("{res}");
                    }
                    Logs::List => client.root_logs_file_list()?,
                    Logs::Read { name } => {
                        if let Some(name) = name {
                            client.root_logs_file_read(name)?;
                        } else {
                            client.root_logs_file_read_all()?;
                        }
                    }
                    Logs::Sync { sync } => match sync {
                        Sync::Info => {
                            let remote_metadata = client.root_logs_remote_metadata().await?;
                            let local_metadata = client.root_logs_local_metadata()?;

                            print_logs_metadata_table(remote_metadata, local_metadata);
                        }
                        Sync::All { force } => {
                            client.root_logs_sync(*force, None).await?;
                        }
                        Sync::File { name } => {
                            client.root_logs_sync(None, Some(name)).await?;
                        }
                    },
                }
            }
            Self::Moderation { moderation, host } => {
                let account = get_current_account()?;
                let client = host.client(&account, env)?;

                match moderation {
                    Moderation::Lock { account } => {
                        client.root_lock_account(account.as_str()).await?;
                    }
                    Moderation::Unlock { account } => {
                        client.root_unlock_account(account.as_str()).await?;
                    }
                }
            }
            Self::Accounts { accounts, host } => {
                accounts
                    .handle(
                        host.host_domain.as_deref(),
                        host.danger_accept_invalid_certs,
                        host.insecure,
                        env,
                    )
                    .await?;
            }
            Self::Start { .. } => unreachable!("handled in main.rs"),
        }

        Ok(())
    }
}