agent-workspace-contract 0.7.0

//! Developer-facing Environment resource projections returned by Workspace APIs.

use super::*;

// Product response DTOs. Provider references (external ids), credential hashes
// and provider revisions stay off this plane. The provider name is public
// resource identity and is included so callers can tell moulin from e2b.

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceGrantResource {
    pub id: String,
    pub space_id: String,
    pub principal: PrincipalRef,
    pub capabilities: BTreeSet<SpaceCapability>,
    pub path_prefixes: Vec<String>,
    pub expires_at_ms: Option<u64>,
    pub active: bool,
    pub version: u64,
}

impl From<SpaceGrant> for SpaceGrantResource {
    fn from(record: SpaceGrant) -> Self {
        Self {
            id: record.id,
            space_id: record.space_id,
            principal: record.principal,
            capabilities: record.capabilities,
            path_prefixes: record.path_prefixes,
            expires_at_ms: record.expires_at_ms,
            active: record.active,
            version: record.version,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceCollaborationSessionResource {
    pub id: String,
    pub space_id: String,
    pub principal: PrincipalRef,
    pub delegation_id: Option<String>,
    pub requested_mode: SpaceAccessMode,
    pub effective_mode: SpaceAccessMode,
    pub lifecycle: SpaceSessionLifecycle,
    pub last_heartbeat_at_ms: u64,
    pub expires_at_ms: u64,
    pub version: u64,
}

impl From<SpaceCollaborationSession> for SpaceCollaborationSessionResource {
    fn from(record: SpaceCollaborationSession) -> Self {
        Self {
            id: record.id,
            space_id: record.space_id,
            principal: record.principal,
            delegation_id: record.delegation_id,
            requested_mode: record.requested_mode,
            effective_mode: record.effective_mode,
            lifecycle: record.lifecycle,
            last_heartbeat_at_ms: record.last_heartbeat_at_ms,
            expires_at_ms: record.expires_at_ms,
            version: record.version,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceWriteLeaseResource {
    pub id: String,
    pub space_id: String,
    pub session_id: String,
    pub fencing_token: u64,
    pub version: u64,
    pub acquired_at_ms: u64,
    pub expires_at_ms: u64,
    pub active: bool,
}

impl From<SpaceWriteLease> for SpaceWriteLeaseResource {
    fn from(record: SpaceWriteLease) -> Self {
        Self {
            id: record.id,
            space_id: record.space_id,
            session_id: record.session_id,
            fencing_token: record.fencing_token,
            version: record.version,
            acquired_at_ms: record.acquired_at_ms,
            expires_at_ms: record.expires_at_ms,
            active: record.active,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct DelegationResource {
    pub id: String,
    pub grantor_user_id: String,
    pub delegate_agent_id: String,
    pub computer_ids: BTreeSet<String>,
    pub space_ids: BTreeSet<String>,
    pub capabilities: BTreeSet<SpaceCapability>,
    pub path_prefixes: Vec<String>,
    pub purpose: String,
    pub expires_at_ms: u64,
    pub revoked_at_ms: Option<u64>,
}

impl From<DelegationRecord> for DelegationResource {
    fn from(record: DelegationRecord) -> Self {
        Self {
            id: record.id,
            grantor_user_id: record.grantor_user_id,
            delegate_agent_id: record.delegate_agent_id,
            computer_ids: record.computer_ids,
            space_ids: record.space_ids,
            capabilities: record.capabilities,
            path_prefixes: record.path_prefixes,
            purpose: record.purpose,
            expires_at_ms: record.expires_at_ms,
            revoked_at_ms: record.revoked_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ComputerResource {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub alias: Option<String>,
    pub provider: String,
    pub resources: SandboxResources,
    pub lifecycle: ComputerLifecycle,
    pub capabilities: ProviderCapabilities,
    pub owners: Vec<OwnerRef>,
    pub version: u64,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
}

impl From<ComputerRecord> for ComputerResource {
    fn from(record: ComputerRecord) -> Self {
        Self {
            id: record.id,
            alias: record.alias,
            provider: record.provider_ref.provider,
            resources: record.resources,
            lifecycle: record.lifecycle,
            capabilities: record.capabilities,
            owners: record.owners,
            version: record.version,
            created_at_ms: record.created_at_ms,
            updated_at_ms: record.updated_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceResource {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub alias: Option<String>,
    pub computer_id: String,
    #[serde(default)]
    pub provider: String,
    pub persistence: SpacePersistence,
    pub lifecycle: SpaceLifecycle,
    pub capabilities: ProviderCapabilities,
    pub owners: Vec<OwnerRef>,
    pub source_snapshot_id: Option<String>,
    pub revision: u64,
    pub version: u64,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
}

impl SpaceResource {
    pub fn from_record(record: SpaceRecord, provider: impl Into<String>) -> Self {
        Self {
            id: record.id,
            alias: record.alias,
            computer_id: record.computer_id,
            provider: provider.into(),
            persistence: record.persistence,
            lifecycle: record.lifecycle,
            capabilities: record.capabilities,
            owners: record.owners,
            source_snapshot_id: record.source_snapshot_id,
            revision: record.revision,
            version: record.version,
            created_at_ms: record.created_at_ms,
            updated_at_ms: record.updated_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SandboxResource {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub alias: Option<String>,
    pub resources: SandboxResources,
    pub placement: SandboxPlacement,
    pub lifecycle: SandboxLifecycle,
    pub owners: Vec<OwnerRef>,
    pub capabilities: ProviderCapabilities,
    pub mounts: Vec<SandboxMountRecord>,
    pub expires_at_ms: u64,
    pub version: u64,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
}

impl From<SandboxRecord> for SandboxResource {
    fn from(record: SandboxRecord) -> Self {
        Self {
            id: record.id,
            alias: record.alias,
            resources: record.resources,
            placement: record.placement,
            lifecycle: record.lifecycle,
            owners: record.owners,
            capabilities: record.capabilities,
            mounts: record.mounts,
            expires_at_ms: record.expires_at_ms,
            version: record.version,
            created_at_ms: record.created_at_ms,
            updated_at_ms: record.updated_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SnapshotResource {
    pub id: String,
    pub alias: Option<String>,
    pub provider: String,
    pub visibility: SnapshotVisibility,
    pub owners: Vec<OwnerRef>,
    pub builtin: bool,
    pub created_by: PrincipalRef,
    pub lifecycle: SnapshotLifecycle,
    pub digest: Option<String>,
    pub size_bytes: Option<u64>,
    pub error: Option<String>,
    pub provider_build_id: Option<String>,
    pub build_stage: Option<String>,
    pub build_logs: Vec<String>,
    pub created_at_ms: u64,
}

impl From<SnapshotRecord> for SnapshotResource {
    fn from(record: SnapshotRecord) -> Self {
        Self {
            id: record.id,
            alias: record.alias,
            provider: record.provider,
            visibility: record.visibility,
            owners: record.owners,
            builtin: record.builtin,
            created_by: record.created_by,
            lifecycle: record.lifecycle,
            digest: record.digest,
            size_bytes: record.size_bytes,
            error: record.error,
            provider_build_id: record.provider_build_id,
            build_stage: record.build_stage,
            build_logs: record.build_logs,
            created_at_ms: record.created_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct TemplateVersionResource {
    pub template_id: String,
    pub version: String,
    pub provider: String,
    pub created_by: PrincipalRef,
    pub target: TemplateTarget,
    pub base_snapshot_id: Option<String>,
    pub resource_profile: BTreeMap<String, String>,
    pub parameter_schema: BTreeMap<String, String>,
    pub state: TemplateVersionState,
    pub created_at_ms: u64,
}

impl From<TemplateVersionRecord> for TemplateVersionResource {
    fn from(record: TemplateVersionRecord) -> Self {
        Self {
            template_id: record.template_id,
            version: record.version,
            provider: record.provider,
            created_by: record.created_by,
            target: record.target,
            base_snapshot_id: record.base_snapshot_id,
            resource_profile: record.resource_profile,
            parameter_schema: record.parameter_schema,
            state: record.state,
            created_at_ms: record.created_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceChangeSetResource {
    pub id: String,
    pub source_space_id: String,
    pub target_space_id: String,
    pub base_revision: u64,
    pub created_by_session_id: String,
    pub lifecycle: ChangeSetLifecycle,
    pub created_at_ms: u64,
}

impl From<SpaceChangeSetRecord> for SpaceChangeSetResource {
    fn from(record: SpaceChangeSetRecord) -> Self {
        Self {
            id: record.id,
            source_space_id: record.source_space_id,
            target_space_id: record.target_space_id,
            base_revision: record.base_revision,
            created_by_session_id: record.created_by_session_id,
            lifecycle: record.lifecycle,
            created_at_ms: record.created_at_ms,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceAccessTicketResource {
    pub id: String,
    pub space_id: String,
    pub session_id: String,
    pub mode: SpaceAccessMode,
    pub capability_paths: BTreeMap<SpaceCapability, Vec<String>>,
    pub fencing_token: Option<u64>,
    pub expires_at_ms: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct IssuedSpaceAccessTicketResource {
    pub ticket: SpaceAccessTicketResource,
    pub token: String,
}

impl From<IssuedSpaceAccessTicket> for IssuedSpaceAccessTicketResource {
    fn from(issued: IssuedSpaceAccessTicket) -> Self {
        Self {
            ticket: SpaceAccessTicketResource {
                id: issued.ticket.id,
                space_id: issued.ticket.space_id,
                session_id: issued.ticket.session_id,
                mode: issued.ticket.mode,
                capability_paths: issued.ticket.capability_paths,
                fencing_token: issued.ticket.fencing_token,
                expires_at_ms: issued.ticket.expires_at_ms,
            },
            token: issued.token,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceFileContent {
    #[serde(with = "super::base64_bytes")]
    pub bytes: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpaceFileEntry {
    pub path: String,
    pub is_dir: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size_bytes: Option<u64>,
}

impl From<ProviderFileEntry> for SpaceFileEntry {
    fn from(entry: ProviderFileEntry) -> Self {
        Self {
            path: entry.path,
            is_dir: entry.is_dir,
            size_bytes: entry.size_bytes,
        }
    }
}

impl From<ProviderFileContent> for SpaceFileContent {
    fn from(content: ProviderFileContent) -> Self {
        Self {
            bytes: content.bytes,
        }
    }
}