ordinary 0.13.0

Ordinary CLI
Documentation
#![warn(clippy::all, clippy::pedantic)]
#![allow(clippy::missing_errors_doc)]

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

#[cfg(feature = "mimalloc")]
use mimalloc::MiMalloc;

#[cfg(feature = "mimalloc")]
#[global_allocator]
static GLOBAL: MiMalloc = MiMalloc;

#[cfg(feature = "jemalloc")]
#[cfg(not(target_env = "msvc"))]
use tikv_jemallocator::Jemalloc;

#[cfg(feature = "jemalloc")]
#[cfg(not(target_env = "msvc"))]
#[global_allocator]
static GLOBAL: Jemalloc = Jemalloc;

#[expect(clippy::too_many_lines)]
#[tokio::main]
async fn main() -> anyhow::Result<()> {
    #[cfg(feature = "docs")]
    {
        use clap::{CommandFactory, ValueEnum};

        let markdown: String = clap_markdown::help_markdown::<ordinary::Cli>();

        let docs_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("docs");
        fs_err::create_dir_all(&docs_dir)?;

        fs_err::write(docs_dir.join("cli-reference.md"), markdown)?;

        let outdir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("generated");
        fs_err::create_dir_all(&outdir)?;

        let cmd = ordinary::Cli::command();
        clap_mangen::generate_to(cmd, &outdir)?;

        let mut cmd = ordinary::Cli::command();
        for &shell in clap_complete::Shell::value_variants() {
            clap_complete::generate_to(shell, &mut cmd, env!("CARGO_PKG_NAME"), &outdir)?;
        }
    }

    #[cfg(not(feature = "docs"))]
    {
        use clap::{CommandFactory, Parser};
        use ordinary::Commands;
        use ordinary::{App, Host};
        use ordinary::{deploy_host_local, run, setup};

        use ordinary_config::OrdinaryHostConfig;

        use std::path::Path;

        clap_complete::CompleteEnv::with_factory(ordinary::Cli::command).complete();

        let cli = ordinary::Cli::parse();

        if tokio_rustls::rustls::crypto::ring::default_provider()
            .install_default()
            .is_err()
        {
            tracing::error!("failed to get rustls default provider");
        }

        match cli.commands {
            Commands::Host {
                host:
                    Host::Start {
                        mut app_host,
                        global_args,
                        disable_defaults,
                    },
            } => {
                let project = app_host.project.to_path_buf();

                if !disable_defaults {
                    app_host.insecure = true;
                    app_host.insecure_cookies = true;
                    app_host.danger_dns_no_verify = true;
                }

                let host_cli = ordinaryd::Cli {
                    commands: ordinaryd::Commands::Host {
                        app_host,
                        openapi: true,
                        swagger: true,
                        dedicated_ports: true,
                    },
                    global_args: global_args.clone(),
                };

                let log_level_str = cli
                    .verbosity
                    .tracing_level()
                    .map(|lvl| lvl.as_str().to_ascii_lowercase());

                let (logger, logging) = ordinaryd::setup(&host_cli, log_level_str.as_ref())?;

                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()?;

                let init_cli = ordinaryd::Cli {
                    commands: ordinaryd::Commands::Init {
                        domain: config.domain.clone(),
                        password: "root".to_string(),
                        mfa_stored: true,
                        contacts: vec![],
                        base_app_domains: vec![],
                        privileged_domains: None,
                    },
                    global_args: global_args.clone(),
                };

                if ordinaryd::run(
                    &init_cli,
                    None,
                    config
                        .clone()
                        .logging
                        .unwrap_or_default()
                        .server
                        .unwrap_or_default(),
                )
                .await
                .is_err()
                {
                    tracing::info!("already initialized");
                }

                deploy_host_local(&global_args.data_dir, project, &config)?;

                Box::pin(ordinaryd::run(&host_cli, logger, logging)).await?;
            }
            Commands::App {
                app:
                    App::Start {
                        mut app_host,
                        global_args,
                        host,
                        disable_defaults,
                    },
            } => {
                let project = app_host.project.to_path_buf();

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

                if !disable_defaults {
                    app_host.insecure = true;
                    app_host.insecure_cookies = true;
                }

                let app_cli = ordinaryd::Cli {
                    commands: ordinaryd::Commands::App { app_host, host },
                    global_args,
                };

                let log_level_str = cli
                    .verbosity
                    .tracing_level()
                    .map(|lvl| lvl.as_str().to_ascii_lowercase());

                let (logger, logging) = ordinaryd::setup(&app_cli, log_level_str.as_ref())?;
                Box::pin(ordinaryd::run(&app_cli, logger, logging)).await?;
            }
            _ => {
                setup(&cli)?;
                run(&cli).await?;
            }
        }
    }

    Ok(())
}