systemprompt-api 0.64.0

//! Bridge manifest endpoint.
//!
//! Loads auth, version, tenant, and per-user context, then delegates catalogue
//! assembly, marketplace scoping, per-user filtering, and signing to
//! `systemprompt_marketplace`.
//!
//! Copyright (c) systemprompt.io — Business Source License 1.1.
//! See <https://systemprompt.io> for licensing details.

mod per_user;

use std::sync::Arc;

use axum::Json;
use axum::http::HeaderMap;
use chrono::{DateTime, Duration, Utc};
use systemprompt_config::ProfileBootstrap;
use systemprompt_identifiers::UserId;
use systemprompt_manifest::services::BridgePolicyConfig;
use systemprompt_marketplace::{ManifestService, MarketplaceCandidate};
use systemprompt_models::bridge::manifest::{
    MANIFEST_SCHEMA_VERSION, SignedManifest, SignedManifestEnvelope, manifest_min_bridge_version,
};
use systemprompt_models::bridge::manifest_version::ManifestVersion;
use systemprompt_runtime::AppContext;

use super::bridge::instance_enabled_hosts;
use super::bridge_error::{BridgeError, authenticate_bridge};
use super::{bridge_data, bridge_resolved};
use crate::error::ApiHttpError;
use crate::services::middleware::JwtContextExtractor;
use per_user::{PerUserContext, load_per_user_context, record_catalog_grants};

pub async fn manifest(
    jwt_extractor: Arc<JwtContextExtractor>,
    ctx: AppContext,
    headers: HeaderMap,
) -> Result<Json<SignedManifestEnvelope>, ApiHttpError> {
    let (claims, _user) = authenticate_bridge(&jwt_extractor, &headers).await?;
    let profile = ProfileBootstrap::get()
        .map_err(|e| BridgeError::unavailable("manifest: profile not ready", e))?;
    let tenant_id = profile
        .cloud
        .as_ref()
        .and_then(|cloud| cloud.tenant_id.as_ref())
        .filter(|t| !t.as_str().is_empty())
        .cloned();

    let ManifestStamp {
        manifest_version,
        issued_at,
        not_before,
    } = build_version()?;

    let services = bridge_data::load_services_config()
        .map_err(|e| BridgeError::internal("manifest: services config load failed", e))?;
    let instance_hosts = instance_enabled_hosts(&services);
    let desktop_policy = desktop_policy(&services);

    let (candidate, bridge_policy) = assemble_candidate(
        &ctx,
        profile,
        &claims.user_id,
        services,
        bridge_resolved::Freshness::from_headers(&headers),
    )
    .await?;
    let (entries, _filter_context) = candidate.into_manifest_parts();
    let systemprompt_marketplace::ManifestEntries {
        plugins,
        skills,
        rules,
        agents,
        hooks,
        managed_mcp_servers,
        artifacts,
        marketplaces,
        diagnostics,
    } = entries;

    let PerUserContext {
        user,
        revocations,
        enabled_hosts,
        host_model_protocols,
    } = load_per_user_context(&ctx, &claims.user_id, instance_hosts).await?;

    let manifest = SignedManifest {
        min_schema_version: MANIFEST_SCHEMA_VERSION,
        min_bridge_version: Some(manifest_min_bridge_version(&marketplaces)),
        manifest_version,
        issued_at,
        not_before,
        user_id: claims.user_id,
        tenant_id,
        user,
        plugins,
        skills,
        rules,
        agents,
        hooks,
        managed_mcp_servers,
        revocations,
        enabled_hosts,
        host_model_protocols,
        artifacts,
        allow_claude_ai_connectors: bridge_policy.allow_claude_ai_connectors,
        desktop_policy,
        auto_update: bridge_policy.auto_update,
        diagnostics,
        marketplaces,
    };

    let envelope = ManifestService::seal(&manifest)
        .map_err(|e| BridgeError::internal("manifest signing failed", e))?;
    Ok(Json(envelope))
}

fn desktop_policy(
    services: &systemprompt_manifest::services::ServicesConfig,
) -> systemprompt_models::bridge::desktop_policy::DesktopPolicy {
    services
        .external_agents
        .values()
        .find(|agent| agent.id.as_str() == "claude_desktop")
        .map(|agent| agent.desktop_policy.clone())
        .unwrap_or_default()
}

pub(crate) async fn assemble_candidate(
    ctx: &AppContext,
    profile: &systemprompt_manifest::Profile,
    user_id: &UserId,
    services: systemprompt_manifest::services::ServicesConfig,
    freshness: bridge_resolved::Freshness,
) -> Result<(MarketplaceCandidate, BridgePolicyConfig), BridgeError> {
    let bridge_policy = services.bridge_policy.unwrap_or_default();
    let resolved = bridge_resolved::resolve_for_user(ctx, &services, profile, user_id, freshness)
        .await
        .map_err(|e| BridgeError::internal("manifest: catalogue resolution failed", e))?;
    record_catalog_grants(ctx, user_id, &resolved.candidate).await?;
    Ok(((*resolved.candidate).clone(), bridge_policy))
}

struct ManifestStamp {
    manifest_version: ManifestVersion,
    issued_at: DateTime<Utc>,
    not_before: DateTime<Utc>,
}

fn build_version() -> Result<ManifestStamp, BridgeError> {
    let now = Utc::now();
    let issued_at = now;
    let not_before = now - Duration::seconds(60);
    let ts_millis = u64::try_from(now.timestamp_millis())
        .map_err(|e| BridgeError::internal("manifest version: timestamp overflow", e))?;
    let raw = format!("{}-{:016x}", now.format("%Y-%m-%dT%H:%M:%SZ"), ts_millis);
    let version = ManifestVersion::try_new(raw)
        .map_err(|e| BridgeError::internal("manifest version: invalid stamp", e))?;
    Ok(ManifestStamp {
        manifest_version: version,
        issued_at,
        not_before,
    })
}