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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
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}");
}
}