systemprompt_cli/commands/cloud/tenant/docker/

container.rs

//! Lifecycle of the shared Docker `PostgreSQL` container for local tenants.
//!
//! Wraps `docker` invocations to inspect, start, health-check, and tear down
//! the shared container and its volume, and generates the compose file and
//! credentials used to bring it up.

use anyhow::{Context, Result, anyhow, bail};
use std::fs;
use std::path::Path;
use std::time::Duration;
use systemprompt_cloud::{DockerCli, ProjectContext};
use systemprompt_logging::CliService;

use super::config::{SHARED_CONTAINER_NAME, SHARED_VOLUME_NAME, shared_config_path};

pub fn is_shared_container_running(docker: &DockerCli) -> bool {
    let filter = format!("name={}", SHARED_CONTAINER_NAME);
    let output = docker.output(&["ps", "-q", "-f", &filter]);

    match output {
        Ok(out) => !String::from_utf8_lossy(&out.stdout).trim().is_empty(),
        Err(e) => {
            tracing::debug!(error = %e, "Failed to check shared container status");
            false
        },
    }
}

pub fn get_container_password(docker: &DockerCli) -> Option<String> {
    let output = docker.output(&[
        "inspect",
        SHARED_CONTAINER_NAME,
        "--format",
        "{{range .Config.Env}}{{println .}}{{end}}",
    ]);

    match output {
        Ok(out) if out.status.success() => {
            let env_vars = String::from_utf8_lossy(&out.stdout);
            for line in env_vars.lines() {
                if let Some(password) = line.strip_prefix("POSTGRES_PASSWORD=") {
                    return Some(password.to_owned());
                }
            }
            None
        },
        Ok(_out) => {
            tracing::debug!("Docker inspect returned non-success exit code");
            None
        },
        Err(e) => {
            tracing::debug!(error = %e, "Failed to inspect container");
            None
        },
    }
}

pub fn check_volume_exists(docker: &DockerCli) -> bool {
    let filter = format!("name={}", SHARED_VOLUME_NAME);
    let output = docker.output(&["volume", "ls", "-q", "-f", &filter]);

    match output {
        Ok(out) => !String::from_utf8_lossy(&out.stdout).trim().is_empty(),
        Err(e) => {
            tracing::debug!(error = %e, "Failed to check volume existence");
            false
        },
    }
}

pub fn remove_shared_volume(docker: &DockerCli) -> Result<()> {
    let status = docker
        .status(&["volume", "rm", SHARED_VOLUME_NAME])
        .context("Failed to remove PostgreSQL volume")?;

    if !status.success() {
        bail!(
            "Failed to remove volume '{}'. Is a container still using it?",
            SHARED_VOLUME_NAME
        );
    }

    Ok(())
}

pub fn stop_shared_container(docker: &DockerCli) -> Result<()> {
    let ctx = ProjectContext::discover();
    let compose_path = ctx.docker_dir().join("shared.yaml");

    if compose_path.exists() {
        let compose_path_str = compose_path
            .to_str()
            .ok_or_else(|| anyhow!("Invalid compose path"))?;

        CliService::info("Stopping shared PostgreSQL container...");
        let status = docker
            .status(&["compose", "-f", compose_path_str, "down", "-v"])
            .context("Failed to stop shared container")?;

        if !status.success() {
            CliService::warning("Failed to stop container via compose, trying direct stop");
        }
    }

    let filter = format!("name={}", SHARED_CONTAINER_NAME);
    let output = docker.output(&["ps", "-aq", "-f", &filter])?;

    let container_id = String::from_utf8_lossy(&output.stdout).trim().to_owned();
    if !container_id.is_empty() {
        docker.status(&["stop", &container_id])?;
        docker.status(&["rm", &container_id])?;
    }

    let config_path = shared_config_path();
    if config_path.exists() {
        fs::remove_file(&config_path)?;
    }

    CliService::success("Shared PostgreSQL container removed");
    Ok(())
}

pub async fn wait_for_postgres_healthy(
    docker: &DockerCli,
    compose_path: &Path,
    timeout_secs: u64,
) -> Result<()> {
    let start = std::time::Instant::now();
    let compose_path_str = compose_path
        .to_str()
        .ok_or_else(|| anyhow!("Invalid compose path"))?;

    loop {
        let output = docker
            .output(&[
                "compose",
                "-f",
                compose_path_str,
                "ps",
                "--format",
                "{{.Health}}",
            ])
            .context("Failed to check container health")?;

        let health = String::from_utf8_lossy(&output.stdout).trim().to_owned();

        if health.contains("healthy") {
            return Ok(());
        }

        if start.elapsed().as_secs() > timeout_secs {
            bail!(
                "Timeout waiting for PostgreSQL to become healthy.\nCheck logs with: docker \
                 compose -f {} logs",
                compose_path.display()
            );
        }

        tokio::time::sleep(Duration::from_secs(2)).await;
    }
}

pub(in crate::commands::cloud) fn generate_shared_postgres_compose(
    password: &str,
    port: u16,
) -> String {
    format!(
        r#"# systemprompt.io Shared PostgreSQL Container
# Generated by: systemprompt cloud tenant create
# Manage: docker compose -f .systemprompt/docker/shared.yaml up/down

services:
  postgres:
    image: postgres:18-alpine
    container_name: {container_name}
    restart: unless-stopped
    environment:
      POSTGRES_USER: {admin_user}
      POSTGRES_PASSWORD: {password}
      POSTGRES_DB: postgres
    ports:
      - "{port}:5432"
    volumes:
      - {volume_name}:/var/lib/postgresql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U {admin_user}"]
      interval: 5s
      timeout: 5s
      retries: 5

volumes:
  {volume_name}:
    name: {volume_name}
"#,
        container_name = SHARED_CONTAINER_NAME,
        admin_user = super::config::SHARED_ADMIN_USER,
        password = password,
        port = port,
        volume_name = SHARED_VOLUME_NAME
    )
}

pub(in crate::commands::cloud) fn generate_admin_password() -> String {
    use std::time::{SystemTime, UNIX_EPOCH};
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_or(1, |d| d.as_nanos());
    let random_part = format!("{:x}{:x}", timestamp, timestamp.wrapping_mul(31337));
    random_part.chars().take(32).collect()
}

pub(in crate::commands::cloud) fn nanoid() -> String {
    use std::time::{SystemTime, UNIX_EPOCH};
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_or(1, |d| d.as_millis());
    format!("{:x}", timestamp)
}

// `local_` prefix preserved so `is_local_trial()` predicates keep matching;
// suffix is a real RFC-4122 v4 UUID so the canonicalised form (peeled by
// the gateway's bridge-profile handler) is a valid UUID for downstream
// tenant-attribution consumers (e.g. Codex CLI's `x-tenant` header).
#[must_use]
pub(in crate::commands::cloud) fn new_local_tenant_id() -> systemprompt_identifiers::TenantId {
    systemprompt_identifiers::TenantId::new(format!("local_{}", uuid::Uuid::new_v4()))
}