Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

60.3 KB
Raw Blame
use std::collections::{BTreeMap, BTreeSet};
use std::fs::{File, OpenOptions};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::time::Duration;

use fs2::FileExt;
use reqwest::redirect::Policy;
use reqwest::{Client, Url};
use semver::Version;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};

use super::installer::{ensure_update_continuity, validate_key_id, PluginPackageExpectation};
use super::manifest::{parse_host_network_permission, MAX_PLUGIN_NETWORK_ORIGINS};
use super::{
    current_plugin_target, PluginInstallPolicy, PluginInstallResult, PluginPackageInstaller, PluginTrustStore,
    MAX_PLUGIN_PACKAGE_BYTES, SUPPORTED_PLUGIN_PERMISSIONS,
};

pub const SUPPORTED_PLUGIN_CATALOG_VERSION: u32 = 1;
pub const OFFICIAL_PLUGIN_REPOSITORY_ID: &str = "dbx-official";
pub const UNIVERSAL_PLUGIN_TARGET: &str = "universal";
pub const MAX_PLUGIN_CATALOG_BYTES: usize = 4 * 1024 * 1024;

const REPOSITORIES_FILE: &str = ".repositories.json";
const REPOSITORIES_LOCK_FILE: &str = ".repositories.lock";
const OFFICIAL_CATALOG_URL: &str = "https://dl.dbxio.com/catalog/index.json";
const OFFICIAL_CATALOG_FALLBACK_URL: &str = "https://raw.githubusercontent.com/t8y2/dbx-store/main/catalog/index.json";
const ADDITIONAL_OFFICIAL_TRUSTED_KEYS_JSON: Option<&str> = option_env!("DBX_PLUGIN_MARKETPLACE_TRUSTED_KEYS_JSON");
const BUILTIN_OFFICIAL_TRUSTED_KEYS: &[(&str, &str)] = &[
    ("dbx-store-preview-2026", "VRb0VscZfWwuFa7LYfeD/wEOJeyNP8wPGND9br8Icmk="),
    ("dbx-store-release-2026", "6WbMG2UDx+EZ/oauMtHjdinvSD5MuFWSgXbI0n7eL+k="),
];

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum PluginRepositoryKind {
    Official,
    Custom,
    Enterprise,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct PluginRepository {
    pub id: String,
    pub name: String,
    pub kind: PluginRepositoryKind,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub catalog_url: Option<String>,
    #[serde(default = "default_true")]
    pub enabled: bool,
    #[serde(default)]
    pub managed: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PluginMarketplaceRepositoryMetadata {
    pub id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub homepage: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PluginMarketplaceLocalization {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PluginMarketplaceArtifact {
    pub target: String,
    pub url: String,
    pub sha256: String,
    pub signing_key_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PluginMarketplaceVersion {
    pub version: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub released_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub release_notes: Option<String>,
    #[serde(default)]
    pub artifacts: Vec<PluginMarketplaceArtifact>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PluginMarketplacePlugin {
    pub id: String,
    pub name: String,
    #[serde(default)]
    pub description: String,
    pub publisher: String,
    #[serde(default)]
    pub verified: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    #[serde(default)]
    pub tags: Vec<String>,
    #[serde(default)]
    pub permissions: Vec<String>,
    /// The plugin provides MCP tools (its manifest declares an `mcp`
    /// contribution). Lets the store show the MCP mark before install.
    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
    pub mcp_tools: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub homepage: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub license: Option<String>,
    pub latest_version: String,
    #[serde(default)]
    pub versions: Vec<PluginMarketplaceVersion>,
    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
    pub localizations: BTreeMap<String, PluginMarketplaceLocalization>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct PluginMarketplaceCatalog {
    pub catalog_version: u32,
    pub repository: PluginMarketplaceRepositoryMetadata,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub generated_at: Option<String>,
    #[serde(default)]
    pub plugins: Vec<PluginMarketplacePlugin>,
}

#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct PluginRepositoryCatalogResult {
    pub repository: PluginRepository,
    pub target: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub catalog: Option<PluginMarketplaceCatalog>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct PluginMarketplaceInstallRequest {
    pub repository_id: String,
    pub plugin_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    /// Set after the user explicitly confirmed a changed update source (repository / publisher /
    /// signing key) or an intentional downgrade; the install is rejected without it.
    #[serde(default)]
    pub allow_source_change: bool,
}

#[derive(Debug, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct PluginRepositoryDocument {
    #[serde(default = "supported_repository_document_version")]
    version: u32,
    #[serde(default)]
    repositories: Vec<PluginRepository>,
}

#[derive(Debug, Clone)]
pub struct PluginRepositoryStore {
    root_dir: PathBuf,
}

impl PluginRepositoryStore {
    pub fn new(root_dir: PathBuf) -> Self {
        Self { root_dir }
    }

    pub fn list(&self) -> Result<Vec<PluginRepository>, String> {
        let document = self.read_document()?;
        let mut repositories = vec![official_repository()];
        repositories.extend(document.repositories);
        Ok(repositories)
    }

    pub fn find(&self, repository_id: &str) -> Result<PluginRepository, String> {
        self.list()?
            .into_iter()
            .find(|repository| repository.id == repository_id)
            .ok_or_else(|| format!("Plugin repository '{repository_id}' does not exist"))
    }

    pub fn save(&self, mut repository: PluginRepository) -> Result<Vec<PluginRepository>, String> {
        validate_repository(&repository)?;
        if repository.id == OFFICIAL_PLUGIN_REPOSITORY_ID
            || repository.kind == PluginRepositoryKind::Official
            || repository.managed
        {
            return Err("Managed plugin repositories cannot be modified".to_string());
        }
        repository.managed = false;
        let lock = self.open_lock()?;
        lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin repositories: {error}"))?;
        let result = (|| {
            let mut document = self.read_document()?;
            if let Some(existing) = document.repositories.iter_mut().find(|existing| existing.id == repository.id) {
                *existing = repository;
            } else {
                document.repositories.push(repository);
            }
            document.repositories.sort_by(|left, right| left.id.cmp(&right.id));
            write_json_atomically(&self.document_path(), &document)
        })();
        let _ = FileExt::unlock(&lock);
        result?;
        self.list()
    }

    pub fn remove(&self, repository_id: &str) -> Result<Vec<PluginRepository>, String> {
        validate_repository_id(repository_id)?;
        if repository_id == OFFICIAL_PLUGIN_REPOSITORY_ID {
            return Err("Managed plugin repositories cannot be removed".to_string());
        }
        let lock = self.open_lock()?;
        lock.lock_exclusive().map_err(|error| format!("Failed to lock plugin repositories: {error}"))?;
        let result = (|| {
            let mut document = self.read_document()?;
            document.repositories.retain(|repository| repository.id != repository_id);
            write_json_atomically(&self.document_path(), &document)
        })();
        let _ = FileExt::unlock(&lock);
        result?;
        self.list()
    }

    fn document_path(&self) -> PathBuf {
        self.root_dir.join(REPOSITORIES_FILE)
    }

    fn open_lock(&self) -> Result<File, String> {
        std::fs::create_dir_all(&self.root_dir).map_err(|error| error.to_string())?;
        OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .truncate(false)
            .open(self.root_dir.join(REPOSITORIES_LOCK_FILE))
            .map_err(|error| error.to_string())
    }

    fn read_document(&self) -> Result<PluginRepositoryDocument, String> {
        let path = self.document_path();
        let raw = match std::fs::read(&path) {
            Ok(raw) => raw,
            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
                return Ok(PluginRepositoryDocument {
                    version: supported_repository_document_version(),
                    repositories: vec![],
                });
            }
            Err(error) => return Err(format!("Failed to read plugin repositories {}: {error}", path.display())),
        };
        let document: PluginRepositoryDocument = serde_json::from_slice(&raw)
            .map_err(|error| format!("Failed to parse plugin repositories {}: {error}", path.display()))?;
        if document.version != supported_repository_document_version() {
            return Err(format!("Unsupported plugin repository document version {}", document.version));
        }
        for repository in &document.repositories {
            validate_repository(repository)?;
            if repository.id == OFFICIAL_PLUGIN_REPOSITORY_ID
                || repository.kind == PluginRepositoryKind::Official
                || repository.managed
            {
                return Err(format!("Plugin repository '{}' attempts to override a managed repository", repository.id));
            }
        }
        Ok(document)
    }
}

#[derive(Clone)]
pub struct PluginMarketplace {
    root_dir: PathBuf,
    app_version: String,
    repositories: PluginRepositoryStore,
    client: Client,
    lifecycle: Option<super::PluginLifecycle>,
}

impl PluginMarketplace {
    pub fn new(root_dir: PathBuf, app_version: impl Into<String>) -> Result<Self, String> {
        let client = Client::builder()
            .redirect(Policy::limited(5))
            .connect_timeout(Duration::from_secs(10))
            .timeout(Duration::from_secs(300))
            .user_agent(format!("DBX/{}/plugin-marketplace", env!("CARGO_PKG_VERSION")))
            .build()
            .map_err(|error| format!("Failed to create plugin marketplace HTTP client: {error}"))?;
        Ok(Self {
            repositories: PluginRepositoryStore::new(root_dir.clone()),
            root_dir,
            app_version: app_version.into(),
            client,
            lifecycle: None,
        })
    }

    pub fn repositories(&self) -> &PluginRepositoryStore {
        &self.repositories
    }

    pub fn with_lifecycle(mut self, lifecycle: super::PluginLifecycle) -> Self {
        self.lifecycle = Some(lifecycle);
        self
    }

    fn guard_installer(&self, installer: PluginPackageInstaller) -> PluginPackageInstaller {
        match &self.lifecycle {
            Some(lifecycle) => installer.with_lifecycle(lifecycle.clone()),
            None => installer,
        }
    }

    pub async fn fetch_catalogs(&self) -> Vec<PluginRepositoryCatalogResult> {
        let repositories = match self.repositories.list() {
            Ok(repositories) => repositories,
            Err(error) => {
                return vec![PluginRepositoryCatalogResult {
                    repository: official_repository(),
                    target: current_plugin_target(),
                    catalog: None,
                    error: Some(error),
                }];
            }
        };
        self.fetch_catalog_results(repositories).await
    }

    async fn fetch_catalog_results(&self, repositories: Vec<PluginRepository>) -> Vec<PluginRepositoryCatalogResult> {
        let futures = repositories.into_iter().filter(|repository| repository.enabled).map(|repository| async move {
            match self.fetch_catalog(&repository).await {
                Ok(catalog) => PluginRepositoryCatalogResult {
                    repository,
                    target: current_plugin_target(),
                    catalog: Some(catalog),
                    error: None,
                },
                Err(error) => PluginRepositoryCatalogResult {
                    repository,
                    target: current_plugin_target(),
                    catalog: None,
                    error: Some(error),
                },
            }
        });
        futures::future::join_all(futures).await
    }

    pub async fn fetch_catalog(&self, repository: &PluginRepository) -> Result<PluginMarketplaceCatalog, String> {
        validate_repository(repository)?;
        let primary_url = repository_catalog_url(repository)?;
        let (raw, catalog_url) = match self
            .download_limited(primary_url.clone(), MAX_PLUGIN_CATALOG_BYTES, "Plugin catalog", |_, _| {})
            .await
        {
            Ok(raw) => (raw, primary_url),
            Err(primary_error) if repository.id == OFFICIAL_PLUGIN_REPOSITORY_ID => {
                let fallback_url =
                    Url::parse(OFFICIAL_CATALOG_FALLBACK_URL).expect("built-in catalog fallback URL is valid");
                let raw = self
                    .download_limited(fallback_url.clone(), MAX_PLUGIN_CATALOG_BYTES, "Plugin catalog", |_, _| {})
                    .await
                    .map_err(|fallback_error| {
                        format!(
                            "Failed to download official plugin catalog from primary URL ({primary_error}) and fallback URL ({fallback_error})"
                        )
                    })?;
                (raw, fallback_url)
            }
            Err(error) => return Err(error),
        };
        let mut catalog: PluginMarketplaceCatalog = serde_json::from_slice(&raw)
            .map_err(|error| format!("Failed to parse plugin catalog from {catalog_url}: {error}"))?;
        validate_and_resolve_catalog(&mut catalog, repository, &catalog_url)?;
        Ok(catalog)
    }

    pub async fn install(&self, request: PluginMarketplaceInstallRequest) -> Result<PluginInstallResult, String> {
        if let Some(lifecycle) = &self.lifecycle {
            lifecycle.check_update(&request.plugin_id)?;
        }
        let repository = self.repositories.find(&request.repository_id)?;
        if !repository.enabled {
            return Err(format!("Plugin repository '{}' is disabled", repository.id));
        }
        let catalog = self.fetch_catalog(&repository).await?;
        let plugin =
            catalog.plugins.iter().find(|plugin| plugin.id == request.plugin_id).ok_or_else(|| {
                format!("Plugin '{}' is not listed by repository '{}'", request.plugin_id, repository.id)
            })?;
        let requested_version = request.version.as_deref().unwrap_or(&plugin.latest_version);
        let version = plugin
            .versions
            .iter()
            .find(|version| version.version == requested_version)
            .ok_or_else(|| format!("Plugin '{}' version '{}' is not listed", plugin.id, requested_version))?;
        let target = current_plugin_target();
        let artifact = select_marketplace_artifact(version, &target).ok_or_else(|| {
            format!("Plugin '{}' version '{}' does not support target '{}'", plugin.id, version.version, target)
        })?;
        // Read-only provenance pre-flight: reject a source-changed or downgraded update before any
        // download or runtime teardown happens. install_bytes_locked re-checks under the lock.
        let allow_source_change = request.allow_source_change;
        if let Some(identity) = super::installer::read_install_identity(&self.root_dir, &request.plugin_id)? {
            if let Some(provenance) = &identity.provenance {
                ensure_update_continuity(
                    provenance,
                    &identity.version,
                    Some(&repository.id),
                    &plugin.publisher,
                    &artifact.signing_key_id,
                    requested_version,
                    allow_source_change,
                )?;
            }
        }
        let artifact_url =
            Url::parse(&artifact.url).map_err(|error| format!("Invalid plugin artifact URL: {error}"))?;
        let package =
            self.download_limited(artifact_url, MAX_PLUGIN_PACKAGE_BYTES, "Plugin package", |_, _| {}).await?;
        verify_artifact_bytes(artifact, &package)?;
        let trust_store = marketplace_trust_store(&self.root_dir, repository.kind)?;
        let expectation = PluginPackageExpectation {
            id: plugin.id.clone(),
            version: version.version.clone(),
            repository_id: Some(repository.id.clone()),
            publisher: plugin.publisher.clone(),
            permissions: plugin.permissions.iter().cloned().collect(),
            signing_key_id: artifact.signing_key_id.clone(),
        };
        self.guard_installer(PluginPackageInstaller::with_trust_store(
            self.root_dir.clone(),
            self.app_version.clone(),
            trust_store,
        ))
        .install_marketplace_bytes(&package, &expectation, allow_source_change)
    }

    /// Downloads a .dbxp package from a direct http(s) URL and installs it with
    /// the same policy semantics as a local package install, except that
    /// signatures may also verify against the built-in official DBX Marketplace
    /// keys, so store-signed packages install from their direct artifact URLs
    /// as well. No marketplace catalog expectation is applied.
    pub async fn install_url_package<F>(
        &self,
        url: &str,
        policy: PluginInstallPolicy,
        mut on_progress: F,
    ) -> Result<PluginInstallResult, String>
    where
        F: FnMut(u64, Option<u64>),
    {
        let url = parse_http_url(url.trim(), "Plugin package URL")?;
        let package = self.download_limited(url, MAX_PLUGIN_PACKAGE_BYTES, "Plugin package", &mut on_progress).await?;
        self.guard_installer(PluginPackageInstaller::new(self.root_dir.clone(), self.app_version.clone())?)
            .install_bytes_with_expectation(&package, policy, None, super::installer::PluginInstallSource::Url, false)
    }

    /// Thin wrapper over the shared resilient download layer: retries transient
    /// mid-body connection drops (the historical flaky "error decoding response
    /// body" install failures) and resumes from partial bytes via Range requests.
    /// Integrity remains caller-side (size + SHA-256 + signature), so a bad
    /// resume can never be installed.
    async fn download_limited(
        &self,
        url: Url,
        max_bytes: usize,
        label: &str,
        on_progress: impl FnMut(u64, Option<u64>),
    ) -> Result<Vec<u8>, String> {
        dbx_platform::download::resilient_download_bytes(
            &self.client,
            url,
            label,
            max_bytes,
            dbx_platform::download::RESILIENT_DOWNLOAD_ATTEMPTS,
            on_progress,
        )
        .await
    }
}

fn select_marketplace_artifact<'a>(
    version: &'a PluginMarketplaceVersion,
    target: &str,
) -> Option<&'a PluginMarketplaceArtifact> {
    version
        .artifacts
        .iter()
        .find(|artifact| artifact.target == target)
        .or_else(|| version.artifacts.iter().find(|artifact| artifact.target == UNIVERSAL_PLUGIN_TARGET))
}

fn default_true() -> bool {
    true
}

fn supported_repository_document_version() -> u32 {
    1
}

fn official_repository() -> PluginRepository {
    PluginRepository {
        id: OFFICIAL_PLUGIN_REPOSITORY_ID.to_string(),
        name: "DBX Marketplace".to_string(),
        kind: PluginRepositoryKind::Official,
        catalog_url: Some(OFFICIAL_CATALOG_URL.to_string()),
        enabled: true,
        managed: true,
    }
}

fn repository_catalog_url(repository: &PluginRepository) -> Result<Url, String> {
    let raw = repository.catalog_url.as_deref().and_then(trimmed_nonempty).ok_or_else(|| {
        if repository.kind == PluginRepositoryKind::Official {
            "Official DBX Marketplace catalog is not configured in this build".to_string()
        } else {
            format!("Plugin repository '{}' has no catalog URL", repository.id)
        }
    })?;
    parse_http_url(raw, "Plugin repository catalog URL")
}

fn validate_repository(repository: &PluginRepository) -> Result<(), String> {
    validate_repository_id(&repository.id)?;
    if repository.name.trim().is_empty() || repository.name.len() > 128 {
        return Err("Plugin repository name must be between 1 and 128 bytes".to_string());
    }
    if let Some(catalog_url) = repository.catalog_url.as_deref().and_then(trimmed_nonempty) {
        parse_http_url(catalog_url, "Plugin repository catalog URL")?;
    } else if repository.kind != PluginRepositoryKind::Official {
        return Err("Custom plugin repositories require a catalog URL".to_string());
    }
    Ok(())
}

fn validate_repository_id(id: &str) -> Result<(), String> {
    if id.is_empty() || id.len() > 128 {
        return Err("Plugin repository id must be between 1 and 128 bytes".to_string());
    }
    let mut characters = id.chars();
    if !matches!(characters.next(), Some(character) if character.is_ascii_lowercase() || character.is_ascii_digit())
        || !characters.all(|character| {
            character.is_ascii_lowercase() || character.is_ascii_digit() || matches!(character, '.' | '-' | '_')
        })
    {
        return Err(format!("Invalid plugin repository id '{id}'"));
    }
    Ok(())
}

fn validate_and_resolve_catalog(
    catalog: &mut PluginMarketplaceCatalog,
    repository: &PluginRepository,
    catalog_url: &Url,
) -> Result<(), String> {
    if catalog.catalog_version != SUPPORTED_PLUGIN_CATALOG_VERSION {
        return Err(format!(
            "Unsupported plugin catalog version {}; this DBX build supports version {}",
            catalog.catalog_version, SUPPORTED_PLUGIN_CATALOG_VERSION
        ));
    }
    if catalog.repository.id != repository.id {
        return Err(format!(
            "Plugin catalog repository id '{}' does not match configured repository '{}'",
            catalog.repository.id, repository.id
        ));
    }
    if catalog.repository.name.trim().is_empty() {
        return Err("Plugin catalog repository name cannot be empty".to_string());
    }
    let mut plugin_ids = BTreeSet::new();
    for plugin in &mut catalog.plugins {
        validate_plugin_id(&plugin.id)?;
        if !plugin_ids.insert(plugin.id.clone()) {
            return Err(format!("Plugin catalog contains duplicate plugin '{}'", plugin.id));
        }
        if plugin.name.trim().is_empty() || plugin.publisher.trim().is_empty() {
            return Err(format!("Plugin '{}' must declare a name and publisher", plugin.id));
        }
        let permissions = plugin.permissions.iter().collect::<BTreeSet<_>>();
        if permissions.len() != plugin.permissions.len() {
            return Err(format!("Plugin '{}' contains duplicate permissions", plugin.id));
        }
        if let Some(permission) = plugin.permissions.iter().find(|permission| {
            !SUPPORTED_PLUGIN_PERMISSIONS.contains(&permission.as_str())
                && parse_host_network_permission(permission).is_none()
        }) {
            return Err(format!("Plugin '{}' declares unsupported permission '{}'", plugin.id, permission));
        }
        let network_origins = plugin
            .permissions
            .iter()
            .filter_map(|permission| parse_host_network_permission(permission))
            .collect::<BTreeSet<_>>();
        if network_origins.len() > MAX_PLUGIN_NETWORK_ORIGINS {
            return Err(format!(
                "Plugin '{}' declares {} network origins; at most {} are allowed",
                plugin.id,
                network_origins.len(),
                MAX_PLUGIN_NETWORK_ORIGINS
            ));
        }
        let latest = Version::parse(&plugin.latest_version)
            .map_err(|error| format!("Plugin '{}' has invalid latestVersion: {error}", plugin.id))?;
        let mut versions = BTreeSet::new();
        let mut contains_latest = false;
        for version in &mut plugin.versions {
            let parsed = Version::parse(&version.version).map_err(|error| {
                format!("Plugin '{}' has invalid version '{}': {error}", plugin.id, version.version)
            })?;
            if !versions.insert(parsed.clone()) {
                return Err(format!("Plugin '{}' contains duplicate version '{}'", plugin.id, version.version));
            }
            contains_latest |= parsed == latest;
            let mut targets = BTreeSet::new();
            for artifact in &mut version.artifacts {
                validate_target(&artifact.target)?;
                if !targets.insert(artifact.target.clone()) {
                    return Err(format!(
                        "Plugin '{}' version '{}' contains duplicate target '{}'",
                        plugin.id, version.version, artifact.target
                    ));
                }
                validate_sha256(&artifact.sha256)?;
                validate_key_id(&artifact.signing_key_id)?;
                if artifact.size.is_some_and(|size| size > MAX_PLUGIN_PACKAGE_BYTES as u64) {
                    return Err(format!(
                        "Plugin '{}' version '{}' target '{}' exceeds the package size limit",
                        plugin.id, version.version, artifact.target
                    ));
                }
                artifact.url = resolve_http_url(catalog_url, &artifact.url, "Plugin artifact URL")?.to_string();
            }
        }
        if !contains_latest {
            return Err(format!(
                "Plugin '{}' latestVersion '{}' is not present in versions",
                plugin.id, plugin.latest_version
            ));
        }
        if let Some(icon) = plugin.icon.as_deref().and_then(trimmed_nonempty) {
            plugin.icon = Some(resolve_http_url(catalog_url, icon, "Plugin icon URL")?.to_string());
        }
    }
    Ok(())
}

fn validate_plugin_id(id: &str) -> Result<(), String> {
    if id.is_empty() || id.len() > 128 {
        return Err("Marketplace plugin id must be between 1 and 128 bytes".to_string());
    }
    let mut characters = id.chars();
    if !matches!(characters.next(), Some(character) if character.is_ascii_lowercase() || character.is_ascii_digit())
        || !characters.all(|character| {
            character.is_ascii_lowercase() || character.is_ascii_digit() || matches!(character, '.' | '-' | '_')
        })
    {
        return Err(format!("Invalid marketplace plugin id '{id}'"));
    }
    Ok(())
}

fn validate_target(target: &str) -> Result<(), String> {
    if target.is_empty()
        || target.len() > 64
        || !target
            .chars()
            .all(|character| character.is_ascii_lowercase() || character.is_ascii_digit() || character == '-')
    {
        return Err(format!("Invalid plugin artifact target '{target}'"));
    }
    Ok(())
}

fn validate_sha256(sha256: &str) -> Result<(), String> {
    if sha256.len() != 64 || !sha256.bytes().all(|byte| byte.is_ascii_hexdigit()) {
        return Err("Plugin artifact SHA-256 must contain 64 hexadecimal characters".to_string());
    }
    Ok(())
}

fn verify_artifact_bytes(artifact: &PluginMarketplaceArtifact, bytes: &[u8]) -> Result<(), String> {
    if artifact.size.is_some_and(|expected| expected != bytes.len() as u64) {
        return Err(format!(
            "Plugin artifact size mismatch: expected {}, received {}",
            artifact.size.unwrap_or_default(),
            bytes.len()
        ));
    }
    let actual = format!("{:x}", Sha256::digest(bytes));
    if !actual.eq_ignore_ascii_case(&artifact.sha256) {
        return Err(format!("Plugin artifact SHA-256 mismatch: expected {}, received {actual}", artifact.sha256));
    }
    Ok(())
}

fn builtin_official_trusted_keys() -> Result<BTreeMap<String, String>, String> {
    let mut keys = BUILTIN_OFFICIAL_TRUSTED_KEYS
        .iter()
        .map(|(key_id, public_key)| ((*key_id).to_string(), (*public_key).to_string()))
        .collect::<BTreeMap<_, _>>();
    if let Some(raw) = ADDITIONAL_OFFICIAL_TRUSTED_KEYS_JSON.and_then(trimmed_nonempty) {
        let additional: BTreeMap<String, String> = serde_json::from_str(raw)
            .map_err(|error| format!("Failed to parse additional official DBX Marketplace signing keys: {error}"))?;
        for (key_id, public_key) in additional {
            if keys.insert(key_id.clone(), public_key).is_some() {
                return Err(format!("Duplicate official DBX Marketplace signing key '{key_id}'"));
            }
        }
    }
    Ok(keys)
}

fn marketplace_trust_store(root_dir: &Path, kind: PluginRepositoryKind) -> Result<PluginTrustStore, String> {
    if kind != PluginRepositoryKind::Official {
        return PluginTrustStore::load(root_dir);
    }
    let store = PluginTrustStore::from_base64_keys(builtin_official_trusted_keys()?)?;
    if store.is_empty() {
        return Err("Official DBX Marketplace signing keys are empty".to_string());
    }
    Ok(store)
}

/// Trust store for local file and direct URL installs: the user's trusted keys plus the
/// built-in official DBX Marketplace keys. A user-saved key that collides with
/// a builtin key id but carries a different public key is a rotation conflict
/// and fails the install instead of silently overriding the builtin key.
pub(super) fn package_install_trust_store(root_dir: &Path) -> Result<PluginTrustStore, String> {
    let mut keys = PluginTrustStore::list_base64_keys(root_dir)?
        .into_iter()
        .map(|key| (key.key_id, key.public_key))
        .collect::<BTreeMap<_, _>>();
    for (key_id, public_key) in builtin_official_trusted_keys()? {
        if let Some(existing) = keys.get(&key_id) {
            if existing.trim() != public_key {
                return Err(format!(
                    "Trusted plugin key '{key_id}' already exists with a different public key; remove it before installing official store packages"
                ));
            }
            continue;
        }
        keys.insert(key_id, public_key);
    }
    PluginTrustStore::from_base64_keys(keys)
}

pub fn url_install_trust_store(root_dir: &Path) -> Result<PluginTrustStore, String> {
    package_install_trust_store(root_dir)
}

fn parse_http_url(raw: &str, label: &str) -> Result<Url, String> {
    let url = Url::parse(raw).map_err(|error| format!("Invalid {label}: {error}"))?;
    ensure_http_url(url, label)
}

fn resolve_http_url(base: &Url, raw: &str, label: &str) -> Result<Url, String> {
    let url = base.join(raw).map_err(|error| format!("Invalid {label}: {error}"))?;
    ensure_http_url(url, label)
}

fn ensure_http_url(url: Url, label: &str) -> Result<Url, String> {
    if !matches!(url.scheme(), "http" | "https") {
        return Err(format!("{label} must use HTTP or HTTPS"));
    }
    if url.host_str().is_none() {
        return Err(format!("{label} must include a host"));
    }
    Ok(url)
}

fn trimmed_nonempty(value: &str) -> Option<&str> {
    let value = value.trim();
    (!value.is_empty()).then_some(value)
}

fn write_json_atomically<T: Serialize>(path: &Path, value: &T) -> Result<(), String> {
    let parent = path.parent().ok_or("Plugin repository path has no parent")?;
    std::fs::create_dir_all(parent).map_err(|error| error.to_string())?;
    let temporary = parent.join(format!(".{}.tmp", uuid::Uuid::new_v4()));
    let mut file =
        OpenOptions::new().write(true).create_new(true).open(&temporary).map_err(|error| error.to_string())?;
    file.write_all(&serde_json::to_vec_pretty(value).map_err(|error| error.to_string())?)
        .map_err(|error| error.to_string())?;
    file.sync_all().map_err(|error| error.to_string())?;
    // std::fs::rename atomically replaces an existing destination on POSIX
    // and Windows alike; remove-then-rename could lose the repository
    // document to a crash between the two calls.
    crate::plugins::installer::rename_with_transient_lock_retry(&temporary, path).map_err(|error| error.to_string())?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use base64::Engine;
    use ed25519_dalek::{Signer, SigningKey};
    use std::io::Cursor;
    use zip::write::SimpleFileOptions;

    use crate::plugins::{PLUGIN_CHECKSUMS_FILE, PLUGIN_SIGNATURE_FILE};

    fn custom_repository(id: &str) -> PluginRepository {
        PluginRepository {
            id: id.to_string(),
            name: format!("Repository {id}"),
            kind: PluginRepositoryKind::Custom,
            catalog_url: Some(format!("https://plugins.example.com/{id}/catalog/index.json")),
            enabled: true,
            managed: false,
        }
    }

    fn catalog(repository_id: &str) -> PluginMarketplaceCatalog {
        PluginMarketplaceCatalog {
            catalog_version: 1,
            repository: PluginMarketplaceRepositoryMetadata {
                id: repository_id.to_string(),
                name: "Example Marketplace".to_string(),
                homepage: None,
            },
            generated_at: None,
            plugins: vec![PluginMarketplacePlugin {
                id: "example.hello".to_string(),
                name: "Hello".to_string(),
                description: "Example".to_string(),
                publisher: "example".to_string(),
                verified: true,
                icon: Some("../assets/icon.svg".to_string()),
                tags: vec!["hello".to_string()],
                permissions: vec!["host.events".to_string()],
                mcp_tools: false,
                source: None,
                homepage: None,
                license: Some("Apache-2.0".to_string()),
                latest_version: "1.0.0".to_string(),
                versions: vec![PluginMarketplaceVersion {
                    version: "1.0.0".to_string(),
                    released_at: None,
                    release_notes: Some("Initial release".to_string()),
                    artifacts: vec![PluginMarketplaceArtifact {
                        target: current_plugin_target(),
                        url: "../dist/plugin.dbxp".to_string(),
                        sha256: "a".repeat(64),
                        signing_key_id: "example.release".to_string(),
                        size: Some(100),
                    }],
                }],
                localizations: BTreeMap::new(),
            }],
        }
    }

    #[test]
    fn persists_custom_repositories_without_overriding_official() {
        let root = tempfile::tempdir().unwrap();
        let store = PluginRepositoryStore::new(root.path().to_path_buf());
        let repositories = store.save(custom_repository("team-marketplace")).unwrap();
        assert_eq!(repositories.len(), 2);
        assert!(repositories[0].managed);
        assert_eq!(repositories[1].id, "team-marketplace");

        let reloaded = PluginRepositoryStore::new(root.path().to_path_buf()).list().unwrap();
        assert_eq!(reloaded, repositories);
        assert!(store.remove(OFFICIAL_PLUGIN_REPOSITORY_ID).unwrap_err().contains("Managed"));

        let mut override_repository = custom_repository(OFFICIAL_PLUGIN_REPOSITORY_ID);
        override_repository.kind = PluginRepositoryKind::Official;
        override_repository.managed = true;
        assert!(store.save(override_repository).unwrap_err().contains("Managed"));
    }

    #[test]
    fn validates_catalog_and_resolves_relative_urls() {
        let repository = custom_repository("team-marketplace");
        let catalog_url = Url::parse(repository.catalog_url.as_deref().unwrap()).unwrap();
        let mut catalog = catalog(&repository.id);
        validate_and_resolve_catalog(&mut catalog, &repository, &catalog_url).unwrap();

        let plugin = &catalog.plugins[0];
        assert_eq!(plugin.icon.as_deref(), Some("https://plugins.example.com/team-marketplace/assets/icon.svg"));
        assert_eq!(
            plugin.versions[0].artifacts[0].url,
            "https://plugins.example.com/team-marketplace/dist/plugin.dbxp"
        );
    }

    #[test]
    fn validates_declared_network_permissions_in_catalogs() {
        let repository = custom_repository("team-marketplace");
        let catalog_url = Url::parse(repository.catalog_url.as_deref().unwrap()).unwrap();

        let mut valid_catalog = catalog(&repository.id);
        valid_catalog.plugins[0].permissions.push("host.network:https://api.example.com".to_string());
        validate_and_resolve_catalog(&mut valid_catalog, &repository, &catalog_url).unwrap();

        valid_catalog.plugins[0].permissions.push("host.network:http://api.example.com".to_string());
        assert!(validate_and_resolve_catalog(&mut valid_catalog, &repository, &catalog_url)
            .unwrap_err()
            .contains("unsupported permission"));

        let mut too_many_origins_catalog = catalog(&repository.id);
        too_many_origins_catalog.plugins[0].permissions = (0..=MAX_PLUGIN_NETWORK_ORIGINS)
            .map(|index| format!("host.network:https://api{index}.example.com"))
            .collect();
        assert!(validate_and_resolve_catalog(&mut too_many_origins_catalog, &repository, &catalog_url)
            .unwrap_err()
            .contains("network origins"));
    }

    #[test]
    fn selects_exact_marketplace_artifact_before_universal_fallback() {
        let version = PluginMarketplaceVersion {
            version: "1.0.0".to_string(),
            released_at: None,
            release_notes: None,
            artifacts: vec![
                PluginMarketplaceArtifact {
                    target: UNIVERSAL_PLUGIN_TARGET.to_string(),
                    url: "https://plugins.example.com/universal.dbxp".to_string(),
                    sha256: "a".repeat(64),
                    signing_key_id: "example.release".to_string(),
                    size: None,
                },
                PluginMarketplaceArtifact {
                    target: "darwin-arm64".to_string(),
                    url: "https://plugins.example.com/darwin-arm64.dbxp".to_string(),
                    sha256: "b".repeat(64),
                    signing_key_id: "example.release".to_string(),
                    size: None,
                },
            ],
        };

        assert_eq!(
            select_marketplace_artifact(&version, "darwin-arm64").map(|artifact| artifact.target.as_str()),
            Some("darwin-arm64")
        );
    }

    #[test]
    fn falls_back_to_universal_marketplace_artifact() {
        let version = PluginMarketplaceVersion {
            version: "1.0.0".to_string(),
            released_at: None,
            release_notes: None,
            artifacts: vec![PluginMarketplaceArtifact {
                target: UNIVERSAL_PLUGIN_TARGET.to_string(),
                url: "https://plugins.example.com/universal.dbxp".to_string(),
                sha256: "a".repeat(64),
                signing_key_id: "example.release".to_string(),
                size: None,
            }],
        };

        assert_eq!(
            select_marketplace_artifact(&version, "linux-x64").map(|artifact| artifact.target.as_str()),
            Some(UNIVERSAL_PLUGIN_TARGET)
        );
    }

    #[test]
    fn rejects_duplicate_versions_invalid_sha_and_repository_mismatch() {
        let repository = custom_repository("team-marketplace");
        let catalog_url = Url::parse(repository.catalog_url.as_deref().unwrap()).unwrap();

        let mut duplicate = catalog(&repository.id);
        let duplicate_version = duplicate.plugins[0].versions[0].clone();
        duplicate.plugins[0].versions.push(duplicate_version);
        assert!(validate_and_resolve_catalog(&mut duplicate, &repository, &catalog_url)
            .unwrap_err()
            .contains("duplicate version"));

        let mut invalid_sha = catalog(&repository.id);
        invalid_sha.plugins[0].versions[0].artifacts[0].sha256 = "invalid".to_string();
        assert!(validate_and_resolve_catalog(&mut invalid_sha, &repository, &catalog_url)
            .unwrap_err()
            .contains("SHA-256"));

        let mut mismatch = catalog("another-repository");
        assert!(validate_and_resolve_catalog(&mut mismatch, &repository, &catalog_url)
            .unwrap_err()
            .contains("does not match"));
    }

    #[test]
    fn verifies_artifact_size_and_sha256() {
        let bytes = b"plugin-package";
        let artifact = PluginMarketplaceArtifact {
            target: current_plugin_target(),
            url: "https://plugins.example.com/plugin.dbxp".to_string(),
            sha256: format!("{:x}", Sha256::digest(bytes)),
            signing_key_id: "example.release".to_string(),
            size: Some(bytes.len() as u64),
        };
        verify_artifact_bytes(&artifact, bytes).unwrap();

        let mut wrong_sha = artifact.clone();
        wrong_sha.sha256 = "0".repeat(64);
        assert!(verify_artifact_bytes(&wrong_sha, bytes).unwrap_err().contains("SHA-256 mismatch"));

        let mut wrong_size = artifact;
        wrong_size.size = Some(1);
        assert!(verify_artifact_bytes(&wrong_size, bytes).unwrap_err().contains("size mismatch"));
    }

    #[test]
    fn exposes_managed_official_repository() {
        let repository = official_repository();
        assert_eq!(repository.id, OFFICIAL_PLUGIN_REPOSITORY_ID);
        assert_eq!(repository.kind, PluginRepositoryKind::Official);
        assert_eq!(repository.catalog_url.as_deref(), Some(OFFICIAL_CATALOG_URL));
        assert_ne!(OFFICIAL_CATALOG_URL, OFFICIAL_CATALOG_FALLBACK_URL);
        assert!(repository.enabled);
        assert!(repository.managed);
    }

    #[test]
    fn loads_builtin_official_trusted_keys() {
        let root = tempfile::tempdir().unwrap();
        assert!(!marketplace_trust_store(root.path(), PluginRepositoryKind::Official).unwrap().is_empty());
    }

    #[test]
    fn custom_repositories_do_not_implicitly_trust_official_keys() {
        let root = tempfile::tempdir().unwrap();
        for kind in [PluginRepositoryKind::Custom, PluginRepositoryKind::Enterprise] {
            assert!(marketplace_trust_store(root.path(), kind).unwrap().is_empty());
        }
    }

    #[tokio::test]
    async fn isolates_repository_fetch_failures() {
        use tokio::io::{AsyncReadExt, AsyncWriteExt};

        let root = tempfile::tempdir().unwrap();
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let working = PluginRepository {
            catalog_url: Some(format!("http://{address}/catalog.json")),
            ..custom_repository("working-marketplace")
        };
        let broken = PluginRepository {
            catalog_url: Some("http://127.0.0.1:9/catalog.json".to_string()),
            ..custom_repository("broken-marketplace")
        };
        let store = PluginRepositoryStore::new(root.path().to_path_buf());
        store.save(working.clone()).unwrap();
        store.save(broken.clone()).unwrap();
        let body = serde_json::to_vec(&catalog(&working.id)).unwrap();
        let server = tokio::spawn(async move {
            let (mut socket, _) = listener.accept().await.unwrap();
            let mut request = [0u8; 2048];
            let _ = socket.read(&mut request).await.unwrap();
            socket
                .write_all(format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", body.len()).as_bytes())
                .await
                .unwrap();
            socket.write_all(&body).await.unwrap();
        });

        let marketplace = PluginMarketplace::new(root.path().to_path_buf(), "0.5.68").unwrap();
        let results = marketplace.fetch_catalog_results(vec![working.clone(), broken.clone()]).await;
        server.await.unwrap();

        assert!(results.iter().any(|result| result.repository.id == working.id && result.catalog.is_some()));
        assert!(results.iter().any(|result| result.repository.id == broken.id && result.error.is_some()));
    }

    #[tokio::test]
    async fn downloads_and_installs_a_signed_universal_marketplace_package() {
        use tokio::io::{AsyncReadExt, AsyncWriteExt};

        let root = tempfile::tempdir().unwrap();
        let signing_key = SigningKey::from_bytes(&[42u8; 32]);
        let key_id = "example-marketplace-release";
        PluginTrustStore::save_base64_key(
            root.path(),
            key_id,
            &base64::engine::general_purpose::STANDARD.encode(signing_key.verifying_key().as_bytes()),
        )
        .unwrap();
        let package = signed_package(&signing_key, key_id);
        let package_sha256 = format!("{:x}", Sha256::digest(&package));
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let repository = PluginRepository {
            catalog_url: Some(format!("http://{address}/catalog.json")),
            ..custom_repository("install-marketplace")
        };
        PluginRepositoryStore::new(root.path().to_path_buf()).save(repository.clone()).unwrap();
        let catalog = PluginMarketplaceCatalog {
            catalog_version: 1,
            repository: PluginMarketplaceRepositoryMetadata {
                id: repository.id.clone(),
                name: repository.name.clone(),
                homepage: None,
            },
            generated_at: None,
            plugins: vec![PluginMarketplacePlugin {
                id: "marketplace.install".to_string(),
                name: "Marketplace Install".to_string(),
                description: String::new(),
                publisher: "example".to_string(),
                verified: false,
                icon: None,
                tags: vec![],
                permissions: vec![],
                mcp_tools: false,
                source: None,
                homepage: None,
                license: None,
                latest_version: "1.0.0".to_string(),
                versions: vec![PluginMarketplaceVersion {
                    version: "1.0.0".to_string(),
                    released_at: None,
                    release_notes: None,
                    artifacts: vec![PluginMarketplaceArtifact {
                        target: UNIVERSAL_PLUGIN_TARGET.to_string(),
                        url: "package.dbxp".to_string(),
                        sha256: package_sha256,
                        signing_key_id: key_id.to_string(),
                        size: Some(package.len() as u64),
                    }],
                }],
                localizations: BTreeMap::new(),
            }],
        };
        let catalog = serde_json::to_vec(&catalog).unwrap();
        let server = tokio::spawn(async move {
            for _ in 0..2 {
                let (mut socket, _) = listener.accept().await.unwrap();
                let mut request = [0u8; 2048];
                let read = socket.read(&mut request).await.unwrap();
                let request = String::from_utf8_lossy(&request[..read]);
                let body = if request.starts_with("GET /catalog.json ") { &catalog } else { &package };
                socket
                    .write_all(
                        format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", body.len())
                            .as_bytes(),
                    )
                    .await
                    .unwrap();
                socket.write_all(body).await.unwrap();
            }
        });

        let marketplace = PluginMarketplace::new(root.path().to_path_buf(), "0.5.68").unwrap();
        let result = marketplace
            .install(PluginMarketplaceInstallRequest {
                repository_id: repository.id,
                plugin_id: "marketplace.install".to_string(),
                version: None,
                allow_source_change: false,
            })
            .await
            .unwrap();
        server.await.unwrap();

        assert_eq!(result.plugin.manifest.id, "marketplace.install");
        assert_eq!(result.plugin.manifest.version, "1.0.0");
        assert_eq!(result.signature, crate::plugins::PluginSignatureStatus::Trusted { key_id: key_id.to_string() });
    }

    fn signed_package(signing_key: &SigningKey, key_id: &str) -> Vec<u8> {
        let (files, checksums) = plugin_package_files("marketplace.install", "Marketplace Install");
        let signature = serde_json::to_vec_pretty(&serde_json::json!({
            "algorithm": "ed25519",
            "key_id": key_id,
            "signature": base64::engine::general_purpose::STANDARD.encode(signing_key.sign(&checksums).to_bytes())
        }))
        .unwrap();
        zip_package_files(&files, &checksums, Some(&signature))
    }

    fn plugin_package_files(id: &str, name: &str) -> (BTreeMap<String, Vec<u8>>, Vec<u8>) {
        let manifest = serde_json::to_vec_pretty(&serde_json::json!({
            "manifest_version": 1,
            "id": id,
            "name": name,
            "version": "1.0.0",
            "publisher": "example",
            "engines": { "dbx": ">=0.5.0", "host_api": "^1.0" },
            "entrypoints": {
                "backend": {
                    "protocol_versions": [1],
                    "transport": "stdio-jsonl",
                    "executable": "bin/plugin"
                }
            }
        }))
        .unwrap();
        let backend = b"#!/bin/sh\nexit 0\n".to_vec();
        let files = BTreeMap::from([("bin/plugin".to_string(), backend), ("manifest.json".to_string(), manifest)]);
        let checksums = serde_json::to_vec_pretty(&serde_json::json!({
            "algorithm": "sha256",
            "files": files
                .iter()
                .map(|(path, bytes)| (path.clone(), format!("{:x}", Sha256::digest(bytes))))
                .collect::<BTreeMap<_, _>>()
        }))
        .unwrap();
        (files, checksums)
    }

    fn zip_package_files(files: &BTreeMap<String, Vec<u8>>, checksums: &[u8], signature: Option<&[u8]>) -> Vec<u8> {
        let mut output = Cursor::new(Vec::new());
        {
            let mut archive = zip::ZipWriter::new(&mut output);
            for (path, bytes) in files {
                let options = if path == "bin/plugin" {
                    SimpleFileOptions::default().unix_permissions(0o755)
                } else {
                    SimpleFileOptions::default().unix_permissions(0o644)
                };
                archive.start_file(path, options).unwrap();
                archive.write_all(bytes).unwrap();
            }
            archive.start_file(PLUGIN_CHECKSUMS_FILE, SimpleFileOptions::default()).unwrap();
            archive.write_all(checksums).unwrap();
            if let Some(signature) = signature {
                archive.start_file(PLUGIN_SIGNATURE_FILE, SimpleFileOptions::default()).unwrap();
                archive.write_all(signature).unwrap();
            }
            archive.finish().unwrap();
        }
        output.into_inner()
    }

    fn serve_package_once(listener: tokio::net::TcpListener, body: Vec<u8>) -> tokio::task::JoinHandle<()> {
        use tokio::io::{AsyncReadExt, AsyncWriteExt};
        tokio::spawn(async move {
            let (mut socket, _) = listener.accept().await.unwrap();
            let mut request = [0u8; 2048];
            let _ = socket.read(&mut request).await.unwrap();
            socket
                .write_all(
                    format!("HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", body.len())
                        .as_bytes(),
                )
                .await
                .unwrap();
            socket.write_all(&body).await.unwrap();
        })
    }

    #[tokio::test]
    async fn installs_a_signed_package_from_a_direct_url() {
        let root = tempfile::tempdir().unwrap();
        let signing_key = SigningKey::from_bytes(&[7u8; 32]);
        let key_id = "direct-url-release";
        PluginTrustStore::save_base64_key(
            root.path(),
            key_id,
            &base64::engine::general_purpose::STANDARD.encode(signing_key.verifying_key().as_bytes()),
        )
        .unwrap();
        let package = signed_package(&signing_key, key_id);
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let server = serve_package_once(listener, package.clone());
        let marketplace = PluginMarketplace::new(root.path().to_path_buf(), "0.5.68").unwrap();
        let mut last_progress = (0u64, None);
        let result = marketplace
            .install_url_package(
                &format!("http://{address}/plugin.dbxp"),
                PluginInstallPolicy::LocalSigned,
                |downloaded, total| last_progress = (downloaded, total),
            )
            .await
            .unwrap();
        server.await.unwrap();

        assert_eq!(result.plugin.manifest.id, "marketplace.install");
        assert_eq!(result.plugin.manifest.version, "1.0.0");
        assert_eq!(result.signature, crate::plugins::PluginSignatureStatus::Trusted { key_id: key_id.to_string() });
        assert_eq!(last_progress, (package.len() as u64, Some(package.len() as u64)));
    }

    #[tokio::test]
    async fn direct_url_rechecks_runtime_usage_after_download() {
        let root = tempfile::tempdir().unwrap();
        let signing_key = SigningKey::from_bytes(&[7u8; 32]);
        let key_id = "direct-url-release";
        PluginTrustStore::save_base64_key(
            root.path(),
            key_id,
            &base64::engine::general_purpose::STANDARD.encode(signing_key.verifying_key().as_bytes()),
        )
        .unwrap();
        let registry = crate::plugins::PluginRegistry::new_with_app_version(root.path().to_path_buf(), "0.5.68");
        let lifecycle = registry.lifecycle();
        let marketplace =
            PluginMarketplace::new(root.path().to_path_buf(), "0.5.68").unwrap().with_lifecycle(lifecycle.clone());
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let server = serve_package_once(listener, signed_package(&signing_key, key_id));
        let mut connection = None;
        let result = marketplace
            .install_url_package(&format!("http://{address}/plugin.dbxp"), PluginInstallPolicy::LocalSigned, |_, _| {
                connection.get_or_insert_with(|| {
                    lifecycle.begin_connection("marketplace.install", "Started during download").unwrap()
                });
            })
            .await;
        server.await.unwrap();
        assert!(result.unwrap_err().contains("Started during download"));
        assert!(registry.find_plugin("marketplace.install").unwrap().is_none());
        drop(connection);
        assert!(lifecycle.begin_update("marketplace.install").is_ok());
    }

    #[tokio::test]
    async fn marketplace_reports_active_connections_before_fetching_catalogs() {
        let root = tempfile::tempdir().unwrap();
        let lifecycle = crate::plugins::PluginLifecycle::default();
        let marketplace =
            PluginMarketplace::new(root.path().to_path_buf(), "0.5.68").unwrap().with_lifecycle(lifecycle.clone());
        let _connection = lifecycle.begin_connection("marketplace.install", "Production").unwrap();
        let error = marketplace
            .install(super::PluginMarketplaceInstallRequest {
                repository_id: "not-configured".to_string(),
                plugin_id: "marketplace.install".to_string(),
                version: None,
                allow_source_change: false,
            })
            .await
            .unwrap_err();
        assert!(error.contains("Production"));
    }

    #[tokio::test]
    async fn rejects_url_package_signed_by_an_untrusted_key() {
        let root = tempfile::tempdir().unwrap();
        let signing_key = SigningKey::from_bytes(&[9u8; 32]);
        let package = signed_package(&signing_key, "unknown-release");
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let server = serve_package_once(listener, package);
        let marketplace = PluginMarketplace::new(root.path().to_path_buf(), "0.5.68").unwrap();
        let error = marketplace
            .install_url_package(&format!("http://{address}/plugin.dbxp"), PluginInstallPolicy::LocalSigned, |_, _| {})
            .await
            .unwrap_err();
        server.await.unwrap();

        assert!(error.contains("untrusted key"), "unexpected error: {error}");
    }

    #[tokio::test]
    async fn trusts_builtin_official_store_keys_for_url_installs() {
        let root = tempfile::tempdir().unwrap();
        let (files, checksums) = plugin_package_files("marketplace.install", "Marketplace Install");
        let forged_key = SigningKey::from_bytes(&[11u8; 32]);
        let signature = serde_json::to_vec_pretty(&serde_json::json!({
            "algorithm": "ed25519",
            "key_id": "dbx-store-release-2026",
            "signature": base64::engine::general_purpose::STANDARD.encode(forged_key.sign(&checksums).to_bytes())
        }))
        .unwrap();
        let package = zip_package_files(&files, &checksums, Some(&signature));
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let server = serve_package_once(listener, package);
        let marketplace = PluginMarketplace::new(root.path().to_path_buf(), "0.5.68").unwrap();
        let error = marketplace
            .install_url_package(&format!("http://{address}/plugin.dbxp"), PluginInstallPolicy::LocalSigned, |_, _| {})
            .await
            .unwrap_err();
        server.await.unwrap();

        // The builtin official key id must resolve in the merged trust store,
        // so verification reaches the signature check instead of key trust.
        assert!(!error.contains("untrusted key"), "unexpected error: {error}");
        assert!(error.contains("signature verification failed"), "unexpected error: {error}");
    }

    #[tokio::test]
    async fn installs_an_unsigned_url_package_in_development_mode() {
        let root = tempfile::tempdir().unwrap();
        let (files, checksums) = plugin_package_files("marketplace.install", "Marketplace Install");
        let package = zip_package_files(&files, &checksums, None);
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let server = serve_package_once(listener, package);
        let marketplace = PluginMarketplace::new(root.path().to_path_buf(), "0.5.68").unwrap();
        let result = marketplace
            .install_url_package(
                &format!("http://{address}/plugin.dbxp"),
                PluginInstallPolicy::LocalDevelopment,
                |_, _| {},
            )
            .await
            .unwrap();
        server.await.unwrap();

        assert_eq!(result.plugin.manifest.id, "marketplace.install");
        assert_eq!(result.signature, crate::plugins::PluginSignatureStatus::Unsigned);
    }

    #[tokio::test]
    async fn rejects_url_packages_without_an_http_scheme() {
        let root = tempfile::tempdir().unwrap();
        let marketplace = PluginMarketplace::new(root.path().to_path_buf(), "0.5.68").unwrap();
        let error = marketplace
            .install_url_package("ftp://example.com/plugin.dbxp", PluginInstallPolicy::LocalSigned, |_, _| {})
            .await
            .unwrap_err();
        assert!(error.contains("HTTP or HTTPS"), "unexpected error: {error}");
        let error = marketplace
            .install_url_package("not a url", PluginInstallPolicy::LocalSigned, |_, _| {})
            .await
            .unwrap_err();
        assert!(error.contains("Invalid Plugin package URL"), "unexpected error: {error}");
    }
}