systemprompt-cloud 0.2.1

Cloud API client, credentials, OAuth, and tenant management for systemprompt.io AI governance deployments. Remote sync and multi-tenant orchestration for the MCP governance pipeline.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use systemprompt_models::Profile;
use systemprompt_models::profile_bootstrap::ProfileBootstrap;

use crate::api_client::CloudApiClient;
use crate::credentials::CloudCredentials;
use crate::error::{CloudError, CloudResult};
use crate::paths::{CloudPath, get_cloud_paths};
use crate::tenants::{StoredTenant, TenantStore};

#[derive(Debug, Clone)]
pub struct ResolvedTenant {
    // JSON: external vendor identifier
    pub id: String,
    pub name: String,
    pub app_id: Option<String>,
    pub hostname: Option<String>,
    pub region: Option<String>,
}

impl From<StoredTenant> for ResolvedTenant {
    fn from(tenant: StoredTenant) -> Self {
        Self {
            id: tenant.id,
            name: tenant.name,
            app_id: tenant.app_id,
            hostname: tenant.hostname,
            region: tenant.region,
        }
    }
}

#[derive(Debug)]
pub struct CloudContext {
    pub credentials: CloudCredentials,
    pub profile: Option<&'static Profile>,
    pub tenant: Option<ResolvedTenant>,
    pub api_client: CloudApiClient,
}

impl CloudContext {
    pub fn new_authenticated() -> CloudResult<Self> {
        let cloud_paths = get_cloud_paths();
        let creds_path = cloud_paths.resolve(CloudPath::Credentials);
        let credentials = CloudCredentials::load_and_validate_from_path(&creds_path)
            .map_err(|_| CloudError::NotAuthenticated)?;

        let api_client = CloudApiClient::new(&credentials.api_url, &credentials.api_token)
            .map_err(CloudError::Network)?;

        Ok(Self {
            credentials,
            profile: None,
            tenant: None,
            api_client,
        })
    }

    pub fn with_profile(mut self) -> CloudResult<Self> {
        let profile = ProfileBootstrap::get().map_err(|e| CloudError::ProfileRequired {
            message: e.to_string(),
        })?;

        self.profile = Some(profile);

        if let Some(ref cloud_config) = profile.cloud {
            if let Some(ref tenant_id) = cloud_config.tenant_id {
                self.tenant = Self::resolve_tenant(tenant_id)?;
            }
        }

        Ok(self)
    }

    fn resolve_tenant(tenant_id: &str) -> CloudResult<Option<ResolvedTenant>> {
        let cloud_paths = get_cloud_paths();
        let tenants_path = cloud_paths.resolve(CloudPath::Tenants);

        if !tenants_path.exists() {
            return Ok(None);
        }

        let store =
            TenantStore::load_from_path(&tenants_path).map_err(|_| CloudError::TenantsNotSynced)?;

        store.find_tenant(tenant_id).map_or_else(
            || {
                Err(CloudError::TenantNotFound {
                    tenant_id: tenant_id.to_string(),
                })
            },
            |tenant| Ok(Some(ResolvedTenant::from(tenant.clone()))),
        )
    }

    pub fn tenant_id(&self) -> CloudResult<&str> {
        self.tenant
            .as_ref()
            .map(|t| t.id.as_str())
            .ok_or(CloudError::TenantNotConfigured)
    }

    pub fn app_id(&self) -> CloudResult<&str> {
        self.tenant
            .as_ref()
            .and_then(|t| t.app_id.as_deref())
            .ok_or(CloudError::AppNotConfigured)
    }

    #[must_use]
    pub fn tenant_name(&self) -> &str {
        self.tenant.as_ref().map_or("unknown", |t| t.name.as_str())
    }

    #[must_use]
    pub fn hostname(&self) -> Option<&str> {
        self.tenant.as_ref().and_then(|t| t.hostname.as_deref())
    }

    pub fn profile(&self) -> CloudResult<&'static Profile> {
        self.profile.ok_or_else(|| CloudError::ProfileRequired {
            message: "Profile not loaded in context".into(),
        })
    }

    #[must_use]
    pub const fn has_tenant(&self) -> bool {
        self.tenant.is_some()
    }
}