systemprompt_cli/commands/cloud/profile/

profile_steps.rs

//! Shared steps for building a profile from a stored tenant.
//!
//! Provides [`create_profile_for_tenant`] and the helpers that resolve a
//! tenant from CLI args and refresh masked cloud database credentials before a
//! profile is written.
//!
//! Copyright (c) systemprompt.io — Business Source License 1.1.
//! See <https://systemprompt.io> for licensing details.

use std::path::Path;

use anyhow::{Context, Result, bail};
use systemprompt_cloud::{
    CloudApiClient, ProfilePath, ProjectContext, StoredTenant, TenantStore, TenantType,
};
use systemprompt_logging::CliService;
use systemprompt_models::Profile;

use systemprompt_identifiers::TenantId;

use crate::commands::cloud::tenant::get_credentials;

use systemprompt_models::profile::TrustedIssuer;

use super::api_keys::ApiKeys;
use super::templates::{
    DatabaseUrls, get_services_path, save_dockerfile, save_dockerignore, save_entrypoint,
    save_profile, save_secrets, update_ai_config_default_provider,
};
use super::{CreateArgs, TenantTypeArg};
use crate::interactive::Prompter;
use systemprompt_cloud::profile_authoring::{CloudProfileBuilder, LocalProfileBuilder};

#[derive(Debug)]
pub struct CreatedProfile {
    pub name: String,
}

pub fn create_profile_for_tenant(
    prompter: &dyn Prompter,
    tenant: &StoredTenant,
    api_keys: &ApiKeys,
    profile_name: &str,
    control_plane_api_url: Option<&str>,
) -> Result<CreatedProfile> {
    let ctx = ProjectContext::discover();
    let name = resolve_unique_profile_name(prompter, &ctx, profile_name)?;
    let profile_dir = ctx.profile_dir(&name);

    std::fs::create_dir_all(ctx.profiles_dir())
        .with_context(|| format!("Failed to create {}", ctx.profiles_dir().display()))?;
    ensure_profile_dirs(&ctx, &profile_dir)?;

    write_profile_secrets(tenant, api_keys, &profile_dir)?;
    update_ai_config_default_provider(api_keys.selected_provider())?;

    let profile_path = ProfilePath::Config.resolve(&profile_dir);
    let built_profile = build_tenant_profile(tenant, &name, control_plane_api_url)?;

    save_profile(&built_profile, &profile_path)?;
    CliService::success(&format!("Created: {}", profile_path.display()));

    write_docker_assets(&ctx, &name)?;
    report_profile_validation(&built_profile);

    Ok(CreatedProfile { name })
}

fn resolve_unique_profile_name(
    prompter: &dyn Prompter,
    ctx: &ProjectContext,
    profile_name: &str,
) -> Result<String> {
    let mut name = profile_name.to_owned();

    loop {
        let profile_dir = ctx.profile_dir(&name);
        if !profile_dir.exists() {
            return Ok(name);
        }

        CliService::warning(&format!(
            "Profile '{}' already exists at {}",
            name,
            profile_dir.display()
        ));

        name = prompter.input("Enter a different profile name")?;
    }
}

pub(super) fn ensure_profile_dirs(ctx: &ProjectContext, profile_dir: &Path) -> Result<()> {
    std::fs::create_dir_all(profile_dir)
        .with_context(|| format!("Failed to create directory {}", profile_dir.display()))?;

    std::fs::create_dir_all(ctx.storage_dir()).with_context(|| {
        format!(
            "Failed to create storage directory {}",
            ctx.storage_dir().display()
        )
    })?;

    Ok(())
}

pub(super) fn write_profile_secrets(
    tenant: &StoredTenant,
    api_keys: &ApiKeys,
    profile_dir: &Path,
) -> Result<()> {
    let secrets_path = ProfilePath::Secrets.resolve(profile_dir);
    let local_db_url = tenant
        .get_local_database_url()
        .ok_or_else(|| anyhow::anyhow!("Tenant database URL is required"))?;
    let db_urls = DatabaseUrls {
        external: local_db_url,
        internal: tenant.internal_database_url.as_deref(),
    };
    save_secrets(
        &db_urls,
        api_keys,
        &secrets_path,
        tenant.tenant_type == TenantType::Cloud,
    )?;
    CliService::success(&format!("Created: {}", secrets_path.display()));
    Ok(())
}

fn build_tenant_profile(
    tenant: &StoredTenant,
    name: &str,
    control_plane_api_url: Option<&str>,
) -> Result<Profile> {
    Ok(match tenant.tenant_type {
        TenantType::Local => {
            let services_path = get_services_path()?;
            LocalProfileBuilder::new(name, "./secrets.json", &services_path)
                .with_tenant_id(tenant.id.clone())
                .build()
        },
        TenantType::Cloud => {
            let mut builder = CloudProfileBuilder::new(name)
                .with_tenant_id(tenant.id.clone())
                .with_external_db_access(tenant.external_db_access)
                .with_secrets_path("./secrets.json");
            if let Some(hostname) = &tenant.hostname {
                builder = builder.with_external_url(format!("https://{}", hostname));
            }
            if let Some(api_url) = control_plane_api_url {
                let trimmed = api_url.trim_end_matches('/').to_owned();
                builder = builder.with_trusted_issuer(TrustedIssuer {
                    issuer: trimmed.clone(),
                    jwks_uri: format!("{}/.well-known/jwks.json", trimmed),
                    audience: tenant.id.as_str().to_owned(),
                    typ_allowlist: Vec::new(),
                    allowed_client_ids: Vec::new(),
                    can_issue_id_jag: false,
                });
            }
            builder.build()
        },
    })
}

pub(super) fn write_docker_assets(ctx: &ProjectContext, name: &str) -> Result<()> {
    let docker_dir = ctx.profile_docker_dir(name);
    std::fs::create_dir_all(&docker_dir)
        .with_context(|| format!("Failed to create docker directory {}", docker_dir.display()))?;

    let dockerfile_path = ctx.profile_dockerfile(name);
    save_dockerfile(&dockerfile_path, name, ctx.root())?;
    CliService::success(&format!("Created: {}", dockerfile_path.display()));

    let entrypoint_path = ctx.profile_entrypoint(name);
    save_entrypoint(&entrypoint_path)?;
    CliService::success(&format!("Created: {}", entrypoint_path.display()));

    let dockerignore_path = ctx.profile_dockerignore(name);
    save_dockerignore(&dockerignore_path)?;
    CliService::success(&format!("Created: {}", dockerignore_path.display()));

    Ok(())
}

pub(super) fn report_profile_validation(profile: &Profile) {
    match profile.validate() {
        Ok(()) => CliService::success("Profile validated"),
        Err(e) => CliService::warning(&format!("Validation warning: {}", e)),
    }
}

pub(super) fn resolve_tenant_from_args(
    args: &CreateArgs,
    store: &TenantStore,
) -> Result<StoredTenant> {
    let tenant_id = args.tenant.as_ref().ok_or_else(|| {
        anyhow::anyhow!(
            "Missing required flag: --tenant-id\nIn non-interactive mode, --tenant-id is \
             required.\nList tenants with: systemprompt cloud tenant list"
        )
    })?;

    let tenant = store.find_tenant(&TenantId::new(tenant_id)).ok_or_else(|| {
        anyhow::anyhow!(
            "Tenant '{}' not found.\nList available tenants with: systemprompt cloud tenant list",
            tenant_id
        )
    })?;

    let expected_type: TenantType = match args.tenant_type {
        TenantTypeArg::Local => TenantType::Local,
        TenantTypeArg::Cloud => TenantType::Cloud,
    };

    if tenant.tenant_type != expected_type {
        bail!(
            "Tenant '{}' is type {:?}, but --tenant-type {:?} was specified",
            tenant_id,
            tenant.tenant_type,
            args.tenant_type
        );
    }

    Ok(tenant.clone())
}

struct RefreshedCredentials {
    pub external_database_url: String,
    pub internal_database_url: String,
}

async fn refresh_tenant_credentials(
    client: &CloudApiClient,
    tenant_id: &TenantId,
) -> Result<RefreshedCredentials> {
    let status = client.get_tenant_status(tenant_id).await?;
    let secrets_url = status
        .secrets_url
        .ok_or_else(|| anyhow::anyhow!("No secrets URL available for tenant"))?;
    let secrets = client.fetch_secrets(&secrets_url).await?;
    Ok(RefreshedCredentials {
        external_database_url: secrets.database_url,
        internal_database_url: secrets.internal_database_url,
    })
}

pub(super) async fn ensure_unmasked_credentials(
    tenant: StoredTenant,
    tenants_path: &Path,
) -> Result<StoredTenant> {
    if tenant.tenant_type != TenantType::Cloud {
        return Ok(tenant);
    }

    let external_url = tenant.database_url.as_deref();
    let internal_url = tenant.internal_database_url.as_deref();

    let needs_external = tenant.external_db_access && external_url.is_none();
    let needs_refresh = needs_external
        || external_url.is_some_and(Profile::is_masked_database_url)
        || internal_url.is_none_or(Profile::is_masked_database_url);

    if !needs_refresh {
        return Ok(tenant);
    }

    CliService::info("Fetching database credentials...");
    let creds = get_credentials()?;
    let client = CloudApiClient::new(&creds.api_url, creds.api_token.as_str())?;

    match refresh_tenant_credentials(&client, &TenantId::new(&tenant.id)).await {
        Ok(creds) => {
            let mut updated_tenant = tenant.clone();
            updated_tenant.internal_database_url = Some(creds.internal_database_url);
            if updated_tenant.external_db_access {
                updated_tenant.database_url = Some(creds.external_database_url);
            }

            let mut store = TenantStore::load_from_path(tenants_path)
                .unwrap_or_else(|_| TenantStore::default());
            if let Some(t) = store.tenants.iter_mut().find(|t| t.id == tenant.id) {
                *t = updated_tenant.clone();
                store.save_to_path(tenants_path)?;
            }

            CliService::success("Database credentials retrieved");
            Ok(updated_tenant)
        },
        Err(e) => {
            CliService::warning(&format!("Could not fetch credentials: {}", e));
            CliService::warning(
                "Run 'systemprompt cloud tenant rotate-credentials' to fetch real credentials.",
            );
            Ok(tenant)
        },
    }
}