From 139c451ef306a635d3bd3bb250f9d402d1563049 Mon Sep 17 00:00:00 2001 From: KC <79471844+wolfyy970@users.noreply.github.com> Date: Mon, 3 Aug 2026 14:52:02 -0400 Subject: [PATCH 1/7] feat(desktop): add Project connection setup Signed-off-by: KC <79471844+wolfyy970@users.noreply.github.com> (cherry picked from commit 531a5bddabb961a2f972f1c262d3ea188261a423) --- desktop/playwright.config.ts | 1 + desktop/src-tauri/src/commands/mod.rs | 2 + .../src/commands/project_connections.rs | 52 + desktop/src-tauri/src/lib.rs | 10 +- desktop/src-tauri/src/managed_agents/mod.rs | 1 + .../src/managed_agents/project_connections.rs | 923 ++++++++++++++++++ .../project_connections/probe.rs | 465 +++++++++ .../project_connections/tests.rs | 125 +++ .../project_connections/transactions.rs | 217 ++++ .../projects/projectConnectionHooks.ts | 93 ++ .../projects/ui/ProjectConnectionsPanel.tsx | 708 ++++++++++++++ .../projects/ui/ProjectWorkspaceTabList.tsx | 3 + .../projects/ui/ProjectWorkspaceTabs.tsx | 23 + .../ui/projectConnectionSecrets.test.mjs | 80 ++ .../projects/ui/projectConnectionSecrets.ts | 55 ++ .../projects/ui/projectDetailHelpers.ts | 1 + .../src/shared/api/projectConnectionTypes.ts | 6 + .../src/shared/api/tauriProjectConnections.ts | 121 +++ desktop/src/testing/e2eBridge.ts | 188 ++++ .../project-connections-screenshots.spec.ts | 124 +++ .../synthetic-project-connection-mcp.mjs | 44 + desktop/tests/helpers/bridge.ts | 2 + 22 files changed, 3239 insertions(+), 5 deletions(-) create mode 100644 desktop/src-tauri/src/commands/project_connections.rs create mode 100644 desktop/src-tauri/src/managed_agents/project_connections.rs create mode 100644 desktop/src-tauri/src/managed_agents/project_connections/probe.rs create mode 100644 desktop/src-tauri/src/managed_agents/project_connections/tests.rs create mode 100644 desktop/src-tauri/src/managed_agents/project_connections/transactions.rs create mode 100644 desktop/src/features/projects/projectConnectionHooks.ts create mode 100644 desktop/src/features/projects/ui/ProjectConnectionsPanel.tsx create mode 100644 desktop/src/features/projects/ui/projectConnectionSecrets.test.mjs create mode 100644 desktop/src/features/projects/ui/projectConnectionSecrets.ts create mode 100644 desktop/src/shared/api/projectConnectionTypes.ts create mode 100644 desktop/src/shared/api/tauriProjectConnections.ts create mode 100644 desktop/tests/e2e/project-connections-screenshots.spec.ts create mode 100644 desktop/tests/fixtures/synthetic-project-connection-mcp.mjs diff --git a/desktop/playwright.config.ts b/desktop/playwright.config.ts index c1ea0e061b..f78eeb8b31 100644 --- a/desktop/playwright.config.ts +++ b/desktop/playwright.config.ts @@ -138,6 +138,7 @@ export default defineConfig({ "**/harness-catalog-screenshots.spec.ts", "**/inline-custom-harness.spec.ts", "**/where-to-run-config.spec.ts", + "**/project-connections-screenshots.spec.ts", "**/huddle-transcription.spec.ts", "**/agent-numeric-tuning.spec.ts", "**/needs-restart-screenshots.spec.ts", diff --git a/desktop/src-tauri/src/commands/mod.rs b/desktop/src-tauri/src/commands/mod.rs index 322834630a..dd0b6c8fa7 100644 --- a/desktop/src-tauri/src/commands/mod.rs +++ b/desktop/src-tauri/src/commands/mod.rs @@ -43,6 +43,7 @@ pub mod pairing; mod personas; mod prevent_sleep; mod profile; +mod project_connections; mod project_git; mod project_git_branches; mod project_git_diff; @@ -100,6 +101,7 @@ pub use pairing::*; pub use personas::*; pub use prevent_sleep::*; pub use profile::*; +pub use project_connections::*; pub use project_git::*; pub use project_git_branches::*; pub use project_git_diff::*; diff --git a/desktop/src-tauri/src/commands/project_connections.rs b/desktop/src-tauri/src/commands/project_connections.rs new file mode 100644 index 0000000000..e1675ccebb --- /dev/null +++ b/desktop/src-tauri/src/commands/project_connections.rs @@ -0,0 +1,52 @@ +use tauri::AppHandle; + +use crate::managed_agents::project_connections::{ + self, CreateProjectConnectionRequest, ProjectConnection, ProjectConnectionScope, + UpdateProjectConnectionRequest, +}; + +#[tauri::command] +pub fn list_project_connections( + app: AppHandle, + project_scope: ProjectConnectionScope, +) -> Result, String> { + project_connections::list_project_connections(&app, &project_scope) +} + +#[tauri::command] +pub fn create_project_connection( + app: AppHandle, + input: CreateProjectConnectionRequest, +) -> Result { + project_connections::create_project_connection(&app, input) +} + +#[tauri::command] +pub fn update_project_connection( + app: AppHandle, + input: UpdateProjectConnectionRequest, +) -> Result { + project_connections::update_project_connection(&app, input) +} + +#[tauri::command] +pub async fn test_project_connection( + app: AppHandle, + project_scope: ProjectConnectionScope, + connection_id: String, +) -> Result { + tauri::async_runtime::spawn_blocking(move || { + project_connections::test_project_connection(&app, &project_scope, &connection_id) + }) + .await + .map_err(|error| format!("Project connection test task failed: {error}"))? +} + +#[tauri::command] +pub fn delete_project_connection( + app: AppHandle, + project_scope: ProjectConnectionScope, + connection_id: String, +) -> Result<(), String> { + project_connections::delete_project_connection(&app, &project_scope, &connection_id) +} diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs index 2847b87877..17109455b8 100644 --- a/desktop/src-tauri/src/lib.rs +++ b/desktop/src-tauri/src/lib.rs @@ -141,28 +141,23 @@ pub fn run() { if webview.label() != "main" { return; } - // Linux/WebKitGTK needs media-stream settings and a // permission-request handler for getUserMedia; no-op // on macOS/Windows. linux_media::enable_media_capture(&webview); - // macOS applies the restored geometry asynchronously. Wait // for several identical outer bounds and for React to // commit the startup surface before revealing it. let window = webview.window(); - #[cfg(target_os = "macos")] { set_initial_window_backing(&window); - let (initial_render_tx, initial_render_rx) = tokio::sync::oneshot::channel(); window .app_handle() .once(INITIAL_RENDER_READY_EVENT, move |_| { let _ = initial_render_tx.send(()); }); - tauri::async_runtime::spawn(async move { wait_for_stable_initial_window_geometry(&window).await; @@ -650,6 +645,11 @@ pub fn run() { get_project_local_repo_diff, get_project_local_repo_snapshot, get_project_repo_sync_status, + list_project_connections, + create_project_connection, + update_project_connection, + test_project_connection, + delete_project_connection, list_project_local_repositories, clone_project_repository, create_project_remote_branch, diff --git a/desktop/src-tauri/src/managed_agents/mod.rs b/desktop/src-tauri/src/managed_agents/mod.rs index fe90ce430f..07c724ccae 100644 --- a/desktop/src-tauri/src/managed_agents/mod.rs +++ b/desktop/src-tauri/src/managed_agents/mod.rs @@ -24,6 +24,7 @@ pub(crate) mod persona_events; mod personas; #[cfg(windows)] mod process_lifecycle; +pub(crate) mod project_connections; pub(crate) mod readiness; pub(crate) mod reconcile; mod relay_mesh; diff --git a/desktop/src-tauri/src/managed_agents/project_connections.rs b/desktop/src-tauri/src/managed_agents/project_connections.rs new file mode 100644 index 0000000000..ffff59ebb5 --- /dev/null +++ b/desktop/src-tauri/src/managed_agents/project_connections.rs @@ -0,0 +1,923 @@ +//! Project-owned MCP connection metadata and credentials. +//! +//! Connection metadata is partitioned by the active Buzz community and +//! identity. Secret values are never written to metadata or returned to the +//! webview after a write. + +use std::{ + collections::{BTreeMap, BTreeSet}, + fs, + io::Read as _, + path::{Path, PathBuf}, + sync::{Mutex, MutexGuard}, +}; + +use serde::{Deserialize, Serialize}; +use sha2::{Digest, Sha256}; +use tauri::{AppHandle, Manager as _}; +use uuid::Uuid; + +use super::{atomic_write_json_restricted, managed_agents_base_dir}; +use crate::util::now_iso; +#[cfg(feature = "system-keyring")] +use crate::{app_state::keyring_service, secret_store::SecretStore}; + +const CONNECTION_STORE_VERSION: u32 = 1; +const MAX_CONNECTIONS: usize = 128; +const MAX_NAME_BYTES: usize = 128; +const MAX_PROVIDER_BYTES: usize = 64; +const MAX_COMMAND_BYTES: usize = 1024; +const MAX_ARGS: usize = 128; +const MAX_ARG_BYTES: usize = 4096; +const MAX_ENV_KEYS: usize = 128; +const MAX_SECRET_BYTES: usize = 64 * 1024; +const HEALTH_STALE_AFTER_SECONDS: i64 = 24 * 60 * 60; + +static PROJECT_CONNECTIONS_LOCK: Mutex<()> = Mutex::new(()); + +mod transactions; +use transactions::{commit_delete, commit_update, UpdateTransaction}; + +pub(super) fn lock_project_connections() -> MutexGuard<'static, ()> { + PROJECT_CONNECTIONS_LOCK + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()) +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)] +#[serde(rename_all = "camelCase")] +pub struct ProjectConnectionScope { + pub relay_url: String, + pub operator_pubkey: String, + /// Canonical NIP-34 repository coordinate (`30617::`). + pub repo_address: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(rename_all = "snake_case")] +pub enum ProjectConnectionHealthStatus { + Ready, + NotTested, + CheckNeeded, + SignInRequired, + MissingAccess, + Unavailable, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(rename_all = "camelCase")] +pub struct ProjectConnectionHealth { + pub status: ProjectConnectionHealthStatus, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub last_verified_at: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub detail: Option, +} + +impl Default for ProjectConnectionHealth { + fn default() -> Self { + Self { + status: ProjectConnectionHealthStatus::NotTested, + last_verified_at: None, + detail: None, + } + } +} + +#[derive(Debug, Clone, Serialize, PartialEq, Eq)] +#[serde(rename_all = "camelCase")] +pub struct ProjectConnection { + pub id: String, + pub project_scope: ProjectConnectionScope, + pub name: String, + pub provider: String, + pub capability_ids: Vec, + pub command: String, + pub args: Vec, + /// Names only. Values are never returned by a Tauri command. + pub env_keys: Vec, + pub discovered_tools: Vec, + pub health: ProjectConnectionHealth, + pub created_at: String, + pub updated_at: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(rename_all = "camelCase")] +struct StoredProjectConnection { + id: String, + project_scope: ProjectConnectionScope, + name: String, + provider: String, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + capability_ids: Vec, + command: String, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + args: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + env_keys: Vec, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + discovered_tools: Vec, + #[serde(default)] + health: ProjectConnectionHealth, + executable_sha256: String, + generation: String, + credential_generation: String, + created_at: String, + updated_at: String, +} + +impl From for ProjectConnection { + fn from(connection: StoredProjectConnection) -> Self { + Self { + id: connection.id, + project_scope: connection.project_scope, + name: connection.name, + provider: connection.provider, + capability_ids: connection.capability_ids, + command: connection.command, + args: connection.args, + env_keys: connection.env_keys, + discovered_tools: connection.discovered_tools, + health: connection.health, + created_at: connection.created_at, + updated_at: connection.updated_at, + } + } +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CreateProjectConnectionRequest { + pub project_scope: ProjectConnectionScope, + pub name: String, + pub provider: String, + pub command: String, + #[serde(default)] + pub args: Vec, + /// Secret environment values. They are write-only at this boundary. + #[serde(default)] + pub env: BTreeMap, + #[serde(default)] + pub execution_acknowledged: bool, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct UpdateProjectConnectionRequest { + pub id: String, + pub project_scope: ProjectConnectionScope, + pub name: String, + pub provider: String, + pub command: String, + #[serde(default)] + pub args: Vec, + /// Changed or added values. Omitted keys retain their saved value. + #[serde(default)] + pub env: BTreeMap, + #[serde(default)] + pub remove_env_keys: Vec, + #[serde(default)] + pub execution_acknowledged: bool, +} + +#[derive(Debug, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +struct ProjectConnectionStore { + version: u32, + connections: Vec, +} + +impl Default for ProjectConnectionStore { + fn default() -> Self { + Self { + version: CONNECTION_STORE_VERSION, + connections: Vec::new(), + } + } +} + +fn next_generation() -> String { + Uuid::new_v4().simple().to_string() +} + +fn is_lower_hex(value: &str, length: usize) -> bool { + value.len() == length + && value + .bytes() + .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f')) +} + +fn validate_stored_connection(connection: &StoredProjectConnection) -> Result<(), String> { + if !is_lower_hex(&connection.id, 32) + || !is_lower_hex(&connection.generation, 32) + || !is_lower_hex(&connection.credential_generation, 32) + || !is_lower_hex(&connection.executable_sha256, 64) + || canonical_project_scope(&connection.project_scope)? != connection.project_scope + { + return Err("Project connection metadata is invalid.".to_string()); + } + Ok(()) +} + +fn valid_stable_id(value: &str, max: usize) -> bool { + !value.is_empty() + && value.len() <= max + && value + .bytes() + .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-' | b'.')) +} + +pub(super) fn canonical_project_scope( + scope: &ProjectConnectionScope, +) -> Result { + let relay_url = buzz_core_pkg::relay::normalize_relay_url(&scope.relay_url) + .map_err(|_| "Choose a valid Buzz community before continuing.".to_string())?; + if scope.operator_pubkey.len() != 64 + || !scope + .operator_pubkey + .bytes() + .all(|byte| byte.is_ascii_hexdigit()) + { + return Err("Buzz could not verify who owns these connections.".to_string()); + } + let mut parts = scope.repo_address.splitn(3, ':'); + let kind = parts.next(); + let owner = parts.next(); + let d_tag = parts.next(); + if kind != Some("30617") + || !owner.is_some_and(|value| { + value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_hexdigit()) + }) + || !d_tag.is_some_and(|value| { + !value.is_empty() + && value.len() <= 256 + && !value.chars().any(char::is_control) + && !value.contains(':') + }) + { + return Err("Choose a valid Buzz Project before continuing.".to_string()); + } + Ok(ProjectConnectionScope { + relay_url, + operator_pubkey: scope.operator_pubkey.to_ascii_lowercase(), + repo_address: format!( + "30617:{}:{}", + owner.unwrap_or_default().to_ascii_lowercase(), + d_tag.unwrap_or_default() + ), + }) +} + +fn validate_project_scope_for_app( + app: &AppHandle, + scope: &ProjectConnectionScope, +) -> Result { + let canonical = canonical_project_scope(scope)?; + if canonical != *scope { + return Err("Buzz could not verify this Project's canonical identity.".to_string()); + } + let state = app.state::(); + let active_relay = buzz_core_pkg::relay::normalize_relay_url( + &crate::relay::relay_ws_url_with_override(&state), + ) + .map_err(|_| "Buzz could not verify the active community.".to_string())?; + if canonical.relay_url != active_relay { + return Err("This Project belongs to another Buzz community.".to_string()); + } + let active_operator = state + .keys + .lock() + .map_err(|_| "Buzz could not verify the active identity.".to_string())? + .public_key() + .to_hex(); + if !canonical + .operator_pubkey + .eq_ignore_ascii_case(&active_operator) + { + return Err("These connections belong to another Buzz identity.".to_string()); + } + Ok(canonical) +} + +fn workspace_scope_id(scope: &ProjectConnectionScope) -> String { + let mut hasher = Sha256::new(); + hasher.update(scope.operator_pubkey.as_bytes()); + hasher.update(b"\0"); + hasher.update(scope.relay_url.as_bytes()); + hex::encode(hasher.finalize()) +} + +fn ensure_owner_only_directory(path: &Path) -> Result<(), String> { + match fs::symlink_metadata(path) { + Ok(metadata) if metadata.file_type().is_symlink() || !metadata.is_dir() => { + return Err("Buzz refused an unsafe Project connection directory.".to_string()); + } + Ok(_) => {} + Err(error) if error.kind() == std::io::ErrorKind::NotFound => { + fs::create_dir(path).map_err(|error| { + format!( + "failed to create Project connection directory {}: {error}", + path.display() + ) + })?; + } + Err(error) => { + return Err(format!( + "failed to inspect Project connection directory {}: {error}", + path.display() + )); + } + } + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt as _; + fs::set_permissions(path, fs::Permissions::from_mode(0o700)).map_err(|error| { + format!( + "failed to protect Project connection directory {}: {error}", + path.display() + ) + })?; + } + Ok(()) +} + +fn workspace_connection_dir( + app: &AppHandle, + scope: &ProjectConnectionScope, +) -> Result { + let root = managed_agents_base_dir(app)?.join("project-connections"); + ensure_owner_only_directory(&root)?; + let scoped = root.join(workspace_scope_id(scope)); + ensure_owner_only_directory(&scoped)?; + Ok(scoped) +} + +fn connection_store_path( + app: &AppHandle, + scope: &ProjectConnectionScope, +) -> Result { + Ok(workspace_connection_dir(app, scope)?.join("connections.json")) +} + +fn reject_unsafe_owner_file(path: &Path) -> Result<(), String> { + let metadata = match fs::symlink_metadata(path) { + Ok(metadata) => metadata, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(()), + Err(error) => { + return Err(format!( + "failed to inspect Project connection file {}: {error}", + path.display() + )); + } + }; + if metadata.file_type().is_symlink() || !metadata.is_file() { + return Err("Buzz refused an unsafe Project connection file.".to_string()); + } + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt as _; + if metadata.permissions().mode() & 0o077 != 0 { + return Err( + "Project connection data is not owner-only. Fix its permissions before continuing." + .to_string(), + ); + } + } + Ok(()) +} + +fn load_store_unlocked( + app: &AppHandle, + scope: &ProjectConnectionScope, +) -> Result { + let path = connection_store_path(app, scope)?; + reject_unsafe_owner_file(&path)?; + let bytes = match fs::read(&path) { + Ok(bytes) => bytes, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => { + return Ok(ProjectConnectionStore::default()); + } + Err(error) => { + return Err(format!( + "failed to read Project connections from {}: {error}", + path.display() + )); + } + }; + let store: ProjectConnectionStore = serde_json::from_slice(&bytes) + .map_err(|error| format!("failed to parse Project connections: {error}"))?; + if store.version != CONNECTION_STORE_VERSION { + return Err(format!( + "unsupported Project connection store version {}", + store.version + )); + } + if store.connections.len() > MAX_CONNECTIONS { + return Err("Project connection store exceeds its connection limit".to_string()); + } + for connection in &store.connections { + validate_stored_connection(connection)?; + } + Ok(store) +} + +fn save_store_unlocked( + app: &AppHandle, + scope: &ProjectConnectionScope, + store: &ProjectConnectionStore, +) -> Result<(), String> { + let path = connection_store_path(app, scope)?; + reject_unsafe_owner_file(&path)?; + let bytes = serde_json::to_vec_pretty(store) + .map_err(|error| format!("failed to serialize Project connections: {error}"))?; + atomic_write_json_restricted(&path, &bytes) +} + +#[cfg(feature = "system-keyring")] +fn connection_secret_key( + scope: &ProjectConnectionScope, + id: &str, + credential_generation: &str, +) -> String { + format!( + "project-connection:{}:{id}:{credential_generation}", + workspace_scope_id(scope) + ) +} + +#[cfg(not(feature = "system-keyring"))] +fn connection_secret_path( + app: &AppHandle, + scope: &ProjectConnectionScope, + id: &str, + credential_generation: &str, +) -> Result { + let dir = workspace_connection_dir(app, scope)?.join("secrets"); + ensure_owner_only_directory(&dir)?; + let digest = Sha256::digest(format!("{id}\0{credential_generation}").as_bytes()); + Ok(dir.join(format!("{}.json", hex::encode(digest)))) +} + +fn serialize_secrets(env: &BTreeMap) -> Result, String> { + serde_json::to_vec(env) + .map_err(|error| format!("failed to prepare connection credentials: {error}")) +} + +fn store_secrets( + app: &AppHandle, + scope: &ProjectConnectionScope, + id: &str, + credential_generation: &str, + env: &BTreeMap, +) -> Result<(), String> { + if env.is_empty() { + return delete_secrets(app, scope, id, credential_generation); + } + let serialized = serialize_secrets(env)?; + #[cfg(feature = "system-keyring")] + { + let raw = String::from_utf8(serialized) + .map_err(|_| "Buzz could not prepare these credentials.".to_string())?; + let key = connection_secret_key(scope, id, credential_generation); + let store = SecretStore::shared(keyring_service()); + store.store(&key, &raw).map_err(|_| { + "Buzz could not save these credentials in the system keyring.".to_string() + })?; + if !store + .verify_stored_raw(&key, &raw) + .map_err(|_| "Buzz could not verify the saved credentials.".to_string())? + { + return Err("Buzz could not verify the saved credentials.".to_string()); + } + } + #[cfg(not(feature = "system-keyring"))] + { + let path = connection_secret_path(app, scope, id, credential_generation)?; + reject_unsafe_owner_file(&path)?; + atomic_write_json_restricted(&path, &serialized)?; + } + Ok(()) +} + +fn load_secrets( + app: &AppHandle, + connection: &StoredProjectConnection, +) -> Result, String> { + if connection.env_keys.is_empty() { + return Ok(BTreeMap::new()); + } + #[cfg(feature = "system-keyring")] + let _ = app; + #[cfg(feature = "system-keyring")] + let raw = SecretStore::shared(keyring_service()) + .load(&connection_secret_key( + &connection.project_scope, + &connection.id, + &connection.credential_generation, + )) + .map_err(|_| { + format!( + "Sign in again to '{}'. Buzz could not read its saved credentials.", + connection.name + ) + })? + .ok_or_else(|| { + format!( + "Sign in again to '{}'. Its saved credentials are missing.", + connection.name + ) + })? + .into_bytes(); + #[cfg(not(feature = "system-keyring"))] + let raw = { + let path = connection_secret_path( + app, + &connection.project_scope, + &connection.id, + &connection.credential_generation, + )?; + reject_unsafe_owner_file(&path)?; + fs::read(path).map_err(|_| { + format!( + "Sign in again to '{}'. Its saved credentials are missing.", + connection.name + ) + })? + }; + let env: BTreeMap = serde_json::from_slice(&raw).map_err(|_| { + format!( + "Sign in again to '{}'. Its credentials are invalid.", + connection.name + ) + })?; + let actual: BTreeSet<&str> = env.keys().map(String::as_str).collect(); + let expected: BTreeSet<&str> = connection.env_keys.iter().map(String::as_str).collect(); + if actual != expected { + return Err(format!( + "Sign in again to '{}'. Its saved credentials are incomplete.", + connection.name + )); + } + Ok(env) +} + +fn delete_secrets( + app: &AppHandle, + scope: &ProjectConnectionScope, + id: &str, + credential_generation: &str, +) -> Result<(), String> { + #[cfg(feature = "system-keyring")] + { + let _ = app; + SecretStore::shared(keyring_service()).delete(&connection_secret_key( + scope, + id, + credential_generation, + )) + } + #[cfg(not(feature = "system-keyring"))] + { + let path = connection_secret_path(app, scope, id, credential_generation)?; + match fs::remove_file(path) { + Ok(()) => Ok(()), + Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()), + Err(error) => Err(format!("failed to remove saved credentials: {error}")), + } + } +} + +fn validate_connection_input( + name: &str, + provider: &str, + command: &str, + args: &[String], + env: &BTreeMap, +) -> Result<(), String> { + if name.trim().is_empty() || name.len() > MAX_NAME_BYTES { + return Err("Give this connection a short name.".to_string()); + } + if provider.trim().is_empty() || provider.len() > MAX_PROVIDER_BYTES { + return Err("Name the service this connection uses.".to_string()); + } + if command.trim().is_empty() + || command.len() > MAX_COMMAND_BYTES + || command.contains('\0') + || command.contains('\n') + { + return Err("Enter a valid MCP server executable path.".to_string()); + } + if args.len() > MAX_ARGS + || args + .iter() + .any(|arg| arg.len() > MAX_ARG_BYTES || arg.contains('\0')) + { + return Err("The MCP server arguments exceed Buzz's safety limits.".to_string()); + } + if env.len() > MAX_ENV_KEYS { + return Err("This connection has too many secret values.".to_string()); + } + let mut total = 0usize; + for (key, value) in env { + if !super::is_well_formed_env_key(key) || super::is_reserved_env_key(key) { + return Err(format!( + "'{key}' cannot be used as a connection secret name." + )); + } + if value.is_empty() { + return Err(format!("Enter a value for '{key}' or remove it.")); + } + if value.contains('\0') { + return Err(format!( + "The value for '{key}' contains an invalid character." + )); + } + total = total.saturating_add(key.len()).saturating_add(value.len()); + } + if total > MAX_SECRET_BYTES { + return Err("The connection secret values exceed Buzz's size limit.".to_string()); + } + Ok(()) +} + +fn executable_sha256(path: &Path) -> Result { + let mut file = + fs::File::open(path).map_err(|_| "Buzz could not read this executable.".to_string())?; + let mut digest = Sha256::new(); + let mut buffer = [0u8; 64 * 1024]; + loop { + let count = file + .read(&mut buffer) + .map_err(|_| "Buzz could not read this executable.".to_string())?; + if count == 0 { + break; + } + digest.update(&buffer[..count]); + } + Ok(hex::encode(digest.finalize())) +} + +fn canonical_connection_command(command: &str) -> Result<(String, String), String> { + let path = Path::new(command.trim()); + if !path.is_absolute() { + return Err("Enter the executable's absolute path.".to_string()); + } + let canonical = + fs::canonicalize(path).map_err(|_| "Buzz could not verify this executable.".to_string())?; + let metadata = canonical + .metadata() + .map_err(|_| "Buzz could not verify this executable.".to_string())?; + if !metadata.is_file() { + return Err("The MCP server path is not an executable file.".to_string()); + } + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt as _; + if metadata.permissions().mode() & 0o111 == 0 { + return Err("The MCP server file is not executable.".to_string()); + } + } + let canonical = canonical + .to_str() + .map(str::to_string) + .ok_or_else(|| "The MCP server path is not valid Unicode.".to_string())?; + let fingerprint = executable_sha256(Path::new(&canonical))?; + Ok((canonical, fingerprint)) +} + +fn health_for_display(mut connection: StoredProjectConnection) -> StoredProjectConnection { + if connection.health.status == ProjectConnectionHealthStatus::Ready { + let stale = connection + .health + .last_verified_at + .as_deref() + .and_then(|value| chrono::DateTime::parse_from_rfc3339(value).ok()) + .is_none_or(|verified| { + chrono::Utc::now().signed_duration_since(verified.with_timezone(&chrono::Utc)) + > chrono::Duration::seconds(HEALTH_STALE_AFTER_SECONDS) + }); + if stale { + connection.health.status = ProjectConnectionHealthStatus::CheckNeeded; + } + } + connection +} + +fn find_connection<'a>( + store: &'a ProjectConnectionStore, + project_scope: &ProjectConnectionScope, + connection_id: &str, +) -> Result<&'a StoredProjectConnection, String> { + store + .connections + .iter() + .find(|connection| { + connection.id == connection_id && connection.project_scope == *project_scope + }) + .ok_or_else(|| "This connection no longer exists in this Project.".to_string()) +} + +pub fn list_project_connections( + app: &AppHandle, + project_scope: &ProjectConnectionScope, +) -> Result, String> { + let project_scope = validate_project_scope_for_app(app, project_scope)?; + let _guard = lock_project_connections(); + let mut connections: Vec<_> = load_store_unlocked(app, &project_scope)? + .connections + .into_iter() + .filter(|connection| connection.project_scope == project_scope) + .map(health_for_display) + .map(ProjectConnection::from) + .collect(); + connections.sort_by(|left, right| { + left.name + .to_ascii_lowercase() + .cmp(&right.name.to_ascii_lowercase()) + .then_with(|| left.id.cmp(&right.id)) + }); + Ok(connections) +} + +pub fn create_project_connection( + app: &AppHandle, + mut input: CreateProjectConnectionRequest, +) -> Result { + input.project_scope = validate_project_scope_for_app(app, &input.project_scope)?; + validate_connection_input( + &input.name, + &input.provider, + &input.command, + &input.args, + &input.env, + )?; + if !input.execution_acknowledged { + return Err("Review and acknowledge this local program before saving.".to_string()); + } + let (command, executable_sha256) = canonical_connection_command(&input.command)?; + let _guard = lock_project_connections(); + let mut store = load_store_unlocked(app, &input.project_scope)?; + if store.connections.len() >= MAX_CONNECTIONS { + return Err("Buzz has reached the Project connection limit.".to_string()); + } + let id = Uuid::new_v4().simple().to_string(); + let now = now_iso(); + let credential_generation = next_generation(); + let connection = StoredProjectConnection { + id: id.clone(), + project_scope: input.project_scope.clone(), + name: input.name.trim().to_string(), + provider: input.provider.trim().to_string(), + capability_ids: Vec::new(), + command, + args: input.args, + env_keys: input.env.keys().cloned().collect(), + discovered_tools: Vec::new(), + health: ProjectConnectionHealth::default(), + executable_sha256, + generation: next_generation(), + credential_generation: credential_generation.clone(), + created_at: now.clone(), + updated_at: now, + }; + if !input.env.is_empty() { + store_secrets( + app, + &input.project_scope, + &id, + &credential_generation, + &input.env, + )?; + } + store.connections.push(connection.clone()); + if let Err(error) = save_store_unlocked(app, &input.project_scope, &store) { + if !input.env.is_empty() { + if let Err(cleanup_error) = + delete_secrets(app, &input.project_scope, &id, &credential_generation) + { + return Err(format!( + "{error} Buzz also could not remove the unreferenced credentials: {cleanup_error}" + )); + } + } + return Err(error); + } + Ok(connection.into()) +} + +pub fn update_project_connection( + app: &AppHandle, + mut input: UpdateProjectConnectionRequest, +) -> Result { + input.project_scope = validate_project_scope_for_app(app, &input.project_scope)?; + for key in &input.remove_env_keys { + if !super::is_well_formed_env_key(key) { + return Err("A secret name is invalid.".to_string()); + } + } + let (command, executable_sha256) = canonical_connection_command(&input.command)?; + let _guard = lock_project_connections(); + let mut store = load_store_unlocked(app, &input.project_scope)?; + let previous = find_connection(&store, &input.project_scope, &input.id)?.clone(); + let previous_secrets = load_secrets(app, &previous)?; + let mut next_secrets = previous_secrets.clone(); + for key in &input.remove_env_keys { + next_secrets.remove(key); + } + next_secrets.extend(input.env); + validate_connection_input( + &input.name, + &input.provider, + &command, + &input.args, + &next_secrets, + )?; + let execution_changed = previous.command != command + || previous.executable_sha256 != executable_sha256 + || previous.args != input.args + || previous_secrets != next_secrets; + if execution_changed && !input.execution_acknowledged { + return Err( + "Review and acknowledge the changed program, arguments, and credentials before saving." + .to_string(), + ); + } + let index = store + .connections + .iter() + .position(|connection| connection.id == input.id) + .ok_or_else(|| "This connection no longer exists.".to_string())?; + let mut updated = previous.clone(); + updated.name = input.name.trim().to_string(); + updated.provider = input.provider.trim().to_string(); + updated.command = command; + updated.executable_sha256 = executable_sha256; + updated.args = input.args; + updated.env_keys = next_secrets.keys().cloned().collect(); + updated.generation = next_generation(); + updated.updated_at = now_iso(); + if execution_changed { + updated.capability_ids.clear(); + updated.discovered_tools.clear(); + updated.health = ProjectConnectionHealth::default(); + } + + let secrets_changed = previous_secrets != next_secrets; + if secrets_changed { + updated.credential_generation = next_generation(); + } + commit_update( + &mut store, + UpdateTransaction { + index, + previous: &previous, + updated: &updated, + secrets_changed, + }, + || { + store_secrets( + app, + &input.project_scope, + &input.id, + &updated.credential_generation, + &next_secrets, + ) + }, + |candidate| save_store_unlocked(app, &input.project_scope, candidate), + |generation| delete_secrets(app, &input.project_scope, &input.id, generation), + )?; + Ok(updated.into()) +} + +pub fn delete_project_connection( + app: &AppHandle, + project_scope: &ProjectConnectionScope, + connection_id: &str, +) -> Result<(), String> { + let project_scope = validate_project_scope_for_app(app, project_scope)?; + let _guard = lock_project_connections(); + let mut store = load_store_unlocked(app, &project_scope)?; + let index = store + .connections + .iter() + .position(|connection| { + connection.id == connection_id && connection.project_scope == project_scope + }) + .ok_or_else(|| "This connection no longer exists in this Project.".to_string())?; + if !store.connections[index].env_keys.is_empty() { + load_secrets(app, &store.connections[index])?; + } + commit_delete( + &mut store, + index, + |candidate| save_store_unlocked(app, &project_scope, candidate), + |generation| delete_secrets(app, &project_scope, connection_id, generation), + ) +} + +mod probe; +pub use probe::test_project_connection; + +#[cfg(test)] +mod tests; diff --git a/desktop/src-tauri/src/managed_agents/project_connections/probe.rs b/desktop/src-tauri/src/managed_agents/project_connections/probe.rs new file mode 100644 index 0000000000..309bf1c313 --- /dev/null +++ b/desktop/src-tauri/src/managed_agents/project_connections/probe.rs @@ -0,0 +1,465 @@ +use std::{ + collections::BTreeMap, + io::{BufRead, BufReader, Write as _}, + process::{Child, Command, Stdio}, + sync::Mutex, + time::Duration, +}; + +use super::*; + +const TEST_TIMEOUT: Duration = Duration::from_secs(8); +const CLEANUP_TIMEOUT: Duration = Duration::from_millis(500); +const MAX_RESPONSE_BYTES: usize = 1024 * 1024; +const MAX_DISCOVERED_TOOLS: usize = 256; +const PROBE_BUSY_ERROR: &str = + "Another Project connection is being tested. Try again when it finishes."; +const EXECUTABLE_CHANGED_ERROR: &str = + "This executable changed after it was approved. Edit the connection and review it again."; + +static PROJECT_CONNECTION_PROBE_LOCK: Mutex<()> = Mutex::new(()); + +enum ReaderMessage { + Line(Vec), + Oversized, + Closed, +} + +fn inherited_test_env() -> BTreeMap { + [ + "PATH", + "HOME", + "USER", + "TMPDIR", + "TEMP", + "TMP", + "XDG_CONFIG_HOME", + "XDG_DATA_HOME", + ] + .into_iter() + .filter_map(|key| { + std::env::var(key) + .ok() + .map(|value| (key.to_string(), value)) + }) + .collect() +} + +fn recv_json_response( + rx: &std::sync::mpsc::Receiver, + expected_id: u64, +) -> Result { + let deadline = std::time::Instant::now() + TEST_TIMEOUT; + loop { + let remaining = deadline.saturating_duration_since(std::time::Instant::now()); + let message = rx + .recv_timeout(remaining) + .map_err(|_| "The MCP server did not respond in time.".to_string())?; + let line = match message { + ReaderMessage::Line(line) => line, + ReaderMessage::Oversized => { + return Err("The MCP server returned an oversized response.".to_string()); + } + ReaderMessage::Closed => { + return Err("The MCP server closed before responding.".to_string()); + } + }; + let value: serde_json::Value = serde_json::from_slice(&line) + .map_err(|_| "The MCP server returned an invalid response.".to_string())?; + if value.get("id").and_then(serde_json::Value::as_u64) == Some(expected_id) { + if value.get("error").is_some() { + return Err("The MCP server rejected the request.".to_string()); + } + return value + .get("result") + .cloned() + .ok_or_else(|| "The MCP server returned no result.".to_string()); + } + } +} + +fn read_bounded_line(reader: &mut impl BufRead) -> Result>, ()> { + let mut line = Vec::new(); + let count = reader + .take((MAX_RESPONSE_BYTES + 1) as u64) + .read_until(b'\n', &mut line) + .map_err(|_| ())?; + if count == 0 { + return Ok(None); + } + if line.len() > MAX_RESPONSE_BYTES { + return Err(()); + } + while matches!(line.last(), Some(b'\n' | b'\r')) { + line.pop(); + } + Ok(Some(line)) +} + +fn stop_child(child: &mut Child, pid: u32) -> Result<(), String> { + let termination = super::super::runtime::terminate_process(pid); + let deadline = std::time::Instant::now() + CLEANUP_TIMEOUT; + loop { + match child.try_wait() { + Ok(Some(_)) => { + return termination.map_err(|_| { + "Buzz stopped the MCP server, but could not verify process-group cleanup." + .to_string() + }) + } + Ok(None) if std::time::Instant::now() < deadline => { + std::thread::sleep(Duration::from_millis(10)); + } + Ok(None) => break, + Err(_) => return Err("Buzz could not verify that the MCP server stopped.".to_string()), + } + } + let _ = child.kill(); + let kill_deadline = std::time::Instant::now() + CLEANUP_TIMEOUT; + loop { + match child.try_wait() { + Ok(Some(_)) => { + return Err("Buzz had to force-stop this MCP server after the test.".to_string()); + } + Ok(None) if std::time::Instant::now() < kill_deadline => { + std::thread::sleep(Duration::from_millis(10)); + } + _ => { + return Err("Buzz could not stop this MCP server after the test.".to_string()); + } + } + } +} + +fn verify_saved_executable(connection: &StoredProjectConnection) -> Result<(), String> { + let (canonical, fingerprint) = canonical_connection_command(&connection.command)?; + if canonical != connection.command || fingerprint != connection.executable_sha256 { + return Err(EXECUTABLE_CHANGED_ERROR.to_string()); + } + Ok(()) +} + +fn probe_mcp_connection( + connection: &StoredProjectConnection, + secrets: &BTreeMap, +) -> Result, String> { + let _probe_guard = PROJECT_CONNECTION_PROBE_LOCK + .try_lock() + .map_err(|_| PROBE_BUSY_ERROR.to_string())?; + let mut command = Command::new(&connection.command); + command + .args(&connection.args) + .env_clear() + .envs(inherited_test_env()) + .envs(secrets) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::null()); + #[cfg(unix)] + { + use std::os::unix::process::CommandExt as _; + command.process_group(0); + } + let mut child = command + .spawn() + .map_err(|_| "Buzz could not start this MCP server.".to_string())?; + let pid = child.id(); + let Some(stdout) = child.stdout.take() else { + let _ = stop_child(&mut child, pid); + return Err("Buzz could not read from this MCP server.".to_string()); + }; + let Some(mut stdin) = child.stdin.take() else { + let _ = stop_child(&mut child, pid); + return Err("Buzz could not write to this MCP server.".to_string()); + }; + let (tx, rx) = std::sync::mpsc::channel(); + std::thread::spawn(move || { + let mut reader = BufReader::new(stdout); + loop { + let message = match read_bounded_line(&mut reader) { + Ok(Some(line)) => ReaderMessage::Line(line), + Ok(None) => ReaderMessage::Closed, + Err(()) => ReaderMessage::Oversized, + }; + let terminal = matches!(message, ReaderMessage::Closed | ReaderMessage::Oversized); + if tx.send(message).is_err() || terminal { + return; + } + } + }); + + let result = (|| { + let initialize = serde_json::json!({ + "jsonrpc": "2.0", + "id": 1, + "method": "initialize", + "params": { + "protocolVersion": "2025-06-18", + "capabilities": {}, + "clientInfo": { + "name": "buzz-desktop", + "version": env!("CARGO_PKG_VERSION") + } + } + }); + writeln!(stdin, "{initialize}") + .and_then(|_| stdin.flush()) + .map_err(|_| "Buzz could not initialize this MCP server.".to_string())?; + let initialized = recv_json_response(&rx, 1)?; + if initialized.get("protocolVersion").is_none() { + return Err("The MCP server did not complete initialization.".to_string()); + } + writeln!( + stdin, + "{}", + serde_json::json!({ + "jsonrpc": "2.0", + "method": "notifications/initialized", + "params": {} + }) + ) + .and_then(|_| { + writeln!( + stdin, + "{}", + serde_json::json!({ + "jsonrpc": "2.0", + "id": 2, + "method": "tools/list", + "params": {} + }) + ) + }) + .and_then(|_| stdin.flush()) + .map_err(|_| "Buzz could not inspect this MCP server.".to_string())?; + let tools_result = recv_json_response(&rx, 2)?; + let tools = tools_result + .get("tools") + .and_then(serde_json::Value::as_array) + .ok_or_else(|| "The MCP server did not return a tool list.".to_string())?; + if tools.len() > MAX_DISCOVERED_TOOLS { + return Err("The MCP server returned too many tools.".to_string()); + } + let mut names = Vec::with_capacity(tools.len()); + for tool in tools { + let name = tool + .get("name") + .and_then(serde_json::Value::as_str) + .filter(|name| valid_stable_id(name, 128)) + .ok_or_else(|| "The MCP server returned an invalid tool name.".to_string())?; + names.push(name.to_string()); + } + names.sort(); + names.dedup(); + if names.is_empty() { + return Err("The MCP server did not expose any tools.".to_string()); + } + Ok(names) + })(); + + drop(stdin); + drop(rx); + match stop_child(&mut child, pid) { + Ok(()) => result, + Err(cleanup_error) => Err(cleanup_error), + } +} + +fn safe_health_detail(error: &str) -> String { + match error { + "The MCP server did not respond in time." => error.to_string(), + "Buzz could not start this MCP server." => error.to_string(), + PROBE_BUSY_ERROR | EXECUTABLE_CHANGED_ERROR => error.to_string(), + _ => "Buzz could not verify this MCP server.".to_string(), + } +} + +pub fn test_project_connection( + app: &AppHandle, + project_scope: &ProjectConnectionScope, + connection_id: &str, +) -> Result { + let project_scope = validate_project_scope_for_app(app, project_scope)?; + let connection = { + let _guard = lock_project_connections(); + let store = load_store_unlocked(app, &project_scope)?; + find_connection(&store, &project_scope, connection_id)?.clone() + }; + if let Err(error) = verify_saved_executable(&connection) { + let _guard = lock_project_connections(); + let mut store = load_store_unlocked(app, &project_scope)?; + if let Some(current) = store.connections.iter_mut().find(|candidate| { + candidate.id == connection.id + && candidate.project_scope == project_scope + && candidate.generation == connection.generation + }) { + current.updated_at = now_iso(); + current.health = ProjectConnectionHealth { + status: ProjectConnectionHealthStatus::CheckNeeded, + last_verified_at: None, + detail: Some("Executable approval is out of date.".to_string()), + }; + save_store_unlocked(app, &project_scope, &store)?; + } + return Err(error); + } + let secrets = match load_secrets(app, &connection) { + Ok(secrets) => secrets, + Err(error) => { + let _guard = lock_project_connections(); + let mut store = load_store_unlocked(app, &project_scope)?; + if let Some(current) = store.connections.iter_mut().find(|candidate| { + candidate.id == connection.id + && candidate.project_scope == project_scope + && candidate.generation == connection.generation + }) { + current.updated_at = now_iso(); + current.health = ProjectConnectionHealth { + status: ProjectConnectionHealthStatus::SignInRequired, + last_verified_at: None, + detail: Some("Saved credentials are unavailable.".to_string()), + }; + save_store_unlocked(app, &project_scope, &store)?; + } + return Err(error); + } + }; + let result = probe_mcp_connection(&connection, &secrets); + if matches!(&result, Err(error) if error == PROBE_BUSY_ERROR) { + return Err(PROBE_BUSY_ERROR.to_string()); + } + let _guard = lock_project_connections(); + let mut store = load_store_unlocked(app, &project_scope)?; + let index = store + .connections + .iter() + .position(|candidate| { + candidate.id == connection_id && candidate.project_scope == project_scope + }) + .ok_or_else(|| "This connection was removed while Buzz tested it.".to_string())?; + if store.connections[index].generation != connection.generation { + return Err("This connection changed while Buzz tested it. Test it again.".to_string()); + } + let connection = &mut store.connections[index]; + connection.updated_at = now_iso(); + match result { + Ok(tools) => { + connection.discovered_tools = tools.clone(); + connection.capability_ids = tools + .iter() + .map(|tool| format!("mcp.tool.{tool}")) + .collect(); + connection.health = ProjectConnectionHealth { + status: ProjectConnectionHealthStatus::Ready, + last_verified_at: Some(now_iso()), + detail: None, + }; + let updated = connection.clone(); + save_store_unlocked(app, &project_scope, &store)?; + Ok(updated.into()) + } + Err(error) => { + connection.health = ProjectConnectionHealth { + status: ProjectConnectionHealthStatus::Unavailable, + last_verified_at: None, + detail: Some(safe_health_detail(&error)), + }; + save_store_unlocked(app, &project_scope, &store)?; + Err(error) + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::Cursor; + use std::path::Path; + + #[test] + fn synthetic_server_proves_initialize_and_tool_discovery() { + let node = super::super::super::resolve_command("node") + .expect("Hermit must provide Node for desktop tests"); + let script = Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../tests/fixtures/synthetic-project-connection-mcp.mjs"); + assert!(script.is_file(), "missing fixture {}", script.display()); + let executable_sha256 = executable_sha256(&node).unwrap(); + let connection = StoredProjectConnection { + id: "synthetic-project-connection".to_string(), + project_scope: ProjectConnectionScope { + relay_url: "ws://127.0.0.1:3000".to_string(), + operator_pubkey: "a".repeat(64), + repo_address: format!("30617:{}:portable-agents", "a".repeat(64)), + }, + name: "Synthetic analytics".to_string(), + provider: "Buzz test fixture".to_string(), + capability_ids: Vec::new(), + command: node.to_string_lossy().to_string(), + args: vec![script.to_string_lossy().to_string()], + env_keys: vec!["PROJECT_CONNECTION_CANARY".to_string()], + discovered_tools: Vec::new(), + health: ProjectConnectionHealth::default(), + executable_sha256, + generation: next_generation(), + credential_generation: next_generation(), + created_at: now_iso(), + updated_at: now_iso(), + }; + let secrets = BTreeMap::from([( + "PROJECT_CONNECTION_CANARY".to_string(), + "test-only".to_string(), + )]); + + assert_eq!( + probe_mcp_connection(&connection, &secrets).unwrap(), + ["analytics.weekly_summary"] + ); + } + + #[test] + fn bounded_reader_rejects_a_response_without_a_newline() { + let mut input = Cursor::new(vec![b'x'; MAX_RESPONSE_BYTES + 1]); + assert!(read_bounded_line(&mut input).is_err()); + } + + #[cfg(unix)] + #[test] + fn executable_replacement_invalidates_approval() { + use std::os::unix::fs::PermissionsExt as _; + + let dir = tempfile::tempdir().unwrap(); + let executable = dir.path().join("server"); + fs::write(&executable, b"first").unwrap(); + fs::set_permissions(&executable, fs::Permissions::from_mode(0o700)).unwrap(); + let (command, executable_sha256) = + canonical_connection_command(executable.to_str().unwrap()).unwrap(); + let connection = StoredProjectConnection { + id: "c".repeat(32), + project_scope: ProjectConnectionScope { + relay_url: "ws://127.0.0.1:3000".to_string(), + operator_pubkey: "a".repeat(64), + repo_address: format!("30617:{}:portable-agents", "a".repeat(64)), + }, + name: "Test".to_string(), + provider: "Fixture".to_string(), + capability_ids: Vec::new(), + command, + args: Vec::new(), + env_keys: Vec::new(), + discovered_tools: Vec::new(), + health: ProjectConnectionHealth::default(), + executable_sha256, + generation: next_generation(), + credential_generation: next_generation(), + created_at: now_iso(), + updated_at: now_iso(), + }; + + assert!(verify_saved_executable(&connection).is_ok()); + fs::write(&executable, b"second").unwrap(); + assert_eq!( + verify_saved_executable(&connection).unwrap_err(), + EXECUTABLE_CHANGED_ERROR + ); + } +} diff --git a/desktop/src-tauri/src/managed_agents/project_connections/tests.rs b/desktop/src-tauri/src/managed_agents/project_connections/tests.rs new file mode 100644 index 0000000000..10ba905a67 --- /dev/null +++ b/desktop/src-tauri/src/managed_agents/project_connections/tests.rs @@ -0,0 +1,125 @@ +use super::*; + +fn scope() -> ProjectConnectionScope { + ProjectConnectionScope { + relay_url: "ws://127.0.0.1:3000".to_string(), + operator_pubkey: "b".repeat(64), + repo_address: format!("30617:{}:portable-agents", "a".repeat(64)), + } +} + +fn stored_connection() -> StoredProjectConnection { + StoredProjectConnection { + id: "c".repeat(32), + project_scope: scope(), + name: "Analytics".to_string(), + provider: "Local test".to_string(), + capability_ids: vec!["mcp.tool.run_report".to_string()], + command: "/usr/bin/true".to_string(), + args: Vec::new(), + env_keys: vec!["API_TOKEN".to_string()], + discovered_tools: vec!["run_report".to_string()], + health: ProjectConnectionHealth { + status: ProjectConnectionHealthStatus::Ready, + last_verified_at: Some(now_iso()), + detail: None, + }, + executable_sha256: "d".repeat(64), + generation: "e".repeat(32), + credential_generation: "f".repeat(32), + created_at: now_iso(), + updated_at: now_iso(), + } +} + +#[test] +fn project_scope_requires_canonical_relay_identity_and_coordinate() { + assert_eq!(canonical_project_scope(&scope()).unwrap(), scope()); + let mut invalid = scope(); + invalid.repo_address = "local-project-id".to_string(); + assert!(canonical_project_scope(&invalid).is_err()); + let mut invalid = scope(); + invalid.operator_pubkey = "not-a-key".to_string(); + assert!(canonical_project_scope(&invalid).is_err()); +} + +#[test] +fn public_projection_omits_secret_values_and_internal_generation() { + let public = ProjectConnection::from(stored_connection()); + let json = serde_json::to_value(public).unwrap(); + assert_eq!(json["envKeys"], serde_json::json!(["API_TOKEN"])); + assert!(json.get("generation").is_none()); + assert!(!json.to_string().contains("private-generation")); + assert!(!json.to_string().contains("secret-value")); +} + +#[test] +fn connection_input_rejects_reserved_empty_and_oversized_secrets() { + let valid = BTreeMap::from([("API_TOKEN".to_string(), "value".to_string())]); + assert!(validate_connection_input("Analytics", "Local", "/bin/true", &[], &valid).is_ok()); + let reserved = BTreeMap::from([("BUZZ_PRIVATE_KEY".to_string(), "value".to_string())]); + assert!(validate_connection_input("Analytics", "Local", "/bin/true", &[], &reserved).is_err()); + let empty = BTreeMap::from([("API_TOKEN".to_string(), String::new())]); + assert!(validate_connection_input("Analytics", "Local", "/bin/true", &[], &empty).is_err()); +} + +#[test] +fn stale_ready_connection_is_presented_as_check_needed() { + let mut connection = stored_connection(); + connection.health.last_verified_at = Some("2020-01-01T00:00:00Z".to_string()); + assert_eq!( + health_for_display(connection).health.status, + ProjectConnectionHealthStatus::CheckNeeded + ); +} + +#[test] +fn stored_connection_rejects_invalid_ids_generations_and_fingerprints() { + let mut connection = stored_connection(); + assert!(validate_stored_connection(&connection).is_ok()); + connection.id = "../outside".to_string(); + assert!(validate_stored_connection(&connection).is_err()); + + let mut connection = stored_connection(); + connection.credential_generation = "not-a-generation".to_string(); + assert!(validate_stored_connection(&connection).is_err()); + + let mut connection = stored_connection(); + connection.executable_sha256 = "not-a-fingerprint".to_string(); + assert!(validate_stored_connection(&connection).is_err()); +} + +#[test] +fn connection_lookup_cannot_cross_project_boundaries() { + let connection = stored_connection(); + let store = ProjectConnectionStore { + version: CONNECTION_STORE_VERSION, + connections: vec![connection.clone()], + }; + assert!(find_connection(&store, &connection.project_scope, &connection.id).is_ok()); + + let mut other_project = connection.project_scope; + other_project.repo_address = format!("30617:{}:other-project", "a".repeat(64)); + assert!(find_connection(&store, &other_project, &connection.id).is_err()); +} + +#[cfg(unix)] +#[test] +fn connection_store_rejects_symlinks_and_non_owner_permissions() { + use std::os::unix::fs::{symlink, PermissionsExt as _}; + + let dir = tempfile::tempdir().unwrap(); + let store = dir.path().join("connections.json"); + let target = dir.path().join("target.json"); + fs::write(&target, b"{}").unwrap(); + fs::set_permissions(&target, fs::Permissions::from_mode(0o600)).unwrap(); + symlink(&target, &store).unwrap(); + assert!(reject_unsafe_owner_file(&store).is_err()); + + fs::remove_file(&store).unwrap(); + fs::write(&store, b"{}").unwrap(); + fs::set_permissions(&store, fs::Permissions::from_mode(0o644)).unwrap(); + assert!(reject_unsafe_owner_file(&store).is_err()); + fs::set_permissions(&store, fs::Permissions::from_mode(0o600)).unwrap(); + assert!(reject_unsafe_owner_file(&store).is_ok()); +} diff --git a/desktop/src-tauri/src/managed_agents/project_connections/transactions.rs b/desktop/src-tauri/src/managed_agents/project_connections/transactions.rs new file mode 100644 index 0000000000..baae5cd21d --- /dev/null +++ b/desktop/src-tauri/src/managed_agents/project_connections/transactions.rs @@ -0,0 +1,217 @@ +use super::{ProjectConnectionStore, StoredProjectConnection}; + +pub(super) struct UpdateTransaction<'a> { + pub(super) index: usize, + pub(super) previous: &'a StoredProjectConnection, + pub(super) updated: &'a StoredProjectConnection, + pub(super) secrets_changed: bool, +} + +pub(super) fn commit_update( + store: &mut ProjectConnectionStore, + transaction: UpdateTransaction<'_>, + mut write_new: WriteNew, + mut save_metadata: SaveMetadata, + mut delete_generation: DeleteGeneration, +) -> Result<(), String> +where + WriteNew: FnMut() -> Result<(), String>, + SaveMetadata: FnMut(&ProjectConnectionStore) -> Result<(), String>, + DeleteGeneration: FnMut(&str) -> Result<(), String>, +{ + if transaction.secrets_changed { + write_new()?; + } + store.connections[transaction.index] = transaction.updated.clone(); + if let Err(error) = save_metadata(store) { + store.connections[transaction.index] = transaction.previous.clone(); + if transaction.secrets_changed { + if let Err(cleanup_error) = + delete_generation(&transaction.updated.credential_generation) + { + return Err(format!( + "{error} Buzz also could not remove the unreferenced credentials: {cleanup_error}" + )); + } + } + return Err(error); + } + if transaction.secrets_changed && !transaction.previous.env_keys.is_empty() { + delete_generation(&transaction.previous.credential_generation).map_err(|error| { + format!( + "The connection was updated, but Buzz could not remove its superseded credentials: {error}" + ) + })?; + } + Ok(()) +} + +pub(super) fn commit_delete( + store: &mut ProjectConnectionStore, + index: usize, + mut save_metadata: SaveMetadata, + mut delete_generation: DeleteGeneration, +) -> Result<(), String> +where + SaveMetadata: FnMut(&ProjectConnectionStore) -> Result<(), String>, + DeleteGeneration: FnMut(&str) -> Result<(), String>, +{ + let removed = store.connections.remove(index); + save_metadata(store)?; + if removed.env_keys.is_empty() { + return Ok(()); + } + if let Err(error) = delete_generation(&removed.credential_generation) { + store.connections.insert(index, removed); + return match save_metadata(store) { + Ok(()) => Err(format!( + "Buzz could not remove the saved credentials, so the connection was restored: {error}" + )), + Err(restore_error) => Err(format!( + "Buzz could not remove the saved credentials, and could not restore the connection metadata: {error}; {restore_error}" + )), + }; + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::managed_agents::project_connections::{ + next_generation, ProjectConnectionHealth, ProjectConnectionScope, + }; + + fn connection(env_keys: &[&str]) -> StoredProjectConnection { + StoredProjectConnection { + id: "c".repeat(32), + project_scope: ProjectConnectionScope { + relay_url: "ws://127.0.0.1:3000".to_string(), + operator_pubkey: "a".repeat(64), + repo_address: format!("30617:{}:portable-agents", "a".repeat(64)), + }, + name: "Test".to_string(), + provider: "Fixture".to_string(), + capability_ids: Vec::new(), + command: "/usr/bin/true".to_string(), + args: Vec::new(), + env_keys: env_keys.iter().map(|key| (*key).to_string()).collect(), + discovered_tools: Vec::new(), + health: ProjectConnectionHealth::default(), + executable_sha256: "d".repeat(64), + generation: next_generation(), + credential_generation: next_generation(), + created_at: "2026-08-03T00:00:00Z".to_string(), + updated_at: "2026-08-03T00:00:00Z".to_string(), + } + } + + #[test] + fn update_metadata_failure_removes_only_the_new_secret_generation() { + let previous = connection(&["TOKEN"]); + let mut updated = previous.clone(); + updated.credential_generation = next_generation(); + let mut store = ProjectConnectionStore { + version: 1, + connections: vec![previous.clone()], + }; + let mut deleted = Vec::new(); + + let error = commit_update( + &mut store, + UpdateTransaction { + index: 0, + previous: &previous, + updated: &updated, + secrets_changed: true, + }, + || Ok(()), + |_| Err("metadata failed".to_string()), + |generation| { + deleted.push(generation.to_string()); + Ok(()) + }, + ) + .unwrap_err(); + + assert_eq!(error, "metadata failed"); + assert_eq!(store.connections[0], previous); + assert_eq!(deleted, [updated.credential_generation]); + } + + #[test] + fn update_reports_failed_cleanup_without_repointing_metadata() { + let previous = connection(&["TOKEN"]); + let mut updated = previous.clone(); + updated.credential_generation = next_generation(); + let mut store = ProjectConnectionStore { + version: 1, + connections: vec![previous.clone()], + }; + + let error = commit_update( + &mut store, + UpdateTransaction { + index: 0, + previous: &previous, + updated: &updated, + secrets_changed: true, + }, + || Ok(()), + |_| Err("metadata failed".to_string()), + |_| Err("cleanup failed".to_string()), + ) + .unwrap_err(); + + assert!(error.contains("cleanup failed")); + assert_eq!(store.connections[0], previous); + } + + #[test] + fn failed_secret_delete_restores_connection_metadata() { + let previous = connection(&["TOKEN"]); + let mut store = ProjectConnectionStore { + version: 1, + connections: vec![previous.clone()], + }; + let mut saves = 0; + + let error = commit_delete( + &mut store, + 0, + |_| { + saves += 1; + Ok(()) + }, + |_| Err("keyring failed".to_string()), + ) + .unwrap_err(); + + assert!(error.contains("connection was restored")); + assert_eq!(saves, 2); + assert_eq!(store.connections, [previous]); + } + + #[test] + fn secretless_delete_never_touches_the_credential_backend() { + let mut store = ProjectConnectionStore { + version: 1, + connections: vec![connection(&[])], + }; + let mut credential_calls = 0; + + commit_delete( + &mut store, + 0, + |_| Ok(()), + |_| { + credential_calls += 1; + Ok(()) + }, + ) + .unwrap(); + + assert_eq!(credential_calls, 0); + assert!(store.connections.is_empty()); + } +} diff --git a/desktop/src/features/projects/projectConnectionHooks.ts b/desktop/src/features/projects/projectConnectionHooks.ts new file mode 100644 index 0000000000..31edf9f15b --- /dev/null +++ b/desktop/src/features/projects/projectConnectionHooks.ts @@ -0,0 +1,93 @@ +import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"; + +import { + createProjectConnection, + deleteProjectConnection, + listProjectConnections, + testProjectConnection, + type ProjectConnectionDraft, + updateProjectConnection, +} from "@/shared/api/tauriProjectConnections"; +import type { ProjectConnectionScope } from "@/shared/api/projectConnectionTypes"; + +export const projectConnectionsQueryKey = ( + projectScope: ProjectConnectionScope | null, +) => + [ + "project-connections", + projectScope?.relayUrl ?? "", + projectScope?.operatorPubkey ?? "", + projectScope?.repoAddress ?? "", + ] as const; + +export function useProjectConnectionsQuery( + projectScope: ProjectConnectionScope | null, + options?: { enabled?: boolean }, +) { + return useQuery({ + enabled: Boolean(projectScope) && (options?.enabled ?? true), + queryKey: projectConnectionsQueryKey(projectScope), + queryFn: () => + listProjectConnections(projectScope as ProjectConnectionScope), + }); +} + +export function useCreateProjectConnectionMutation( + projectScope: ProjectConnectionScope, +) { + const queryClient = useQueryClient(); + return useMutation({ + mutationFn: (input: ProjectConnectionDraft) => + createProjectConnection(input), + onSettled: async () => { + await queryClient.invalidateQueries({ + queryKey: projectConnectionsQueryKey(projectScope), + }); + }, + }); +} + +export function useUpdateProjectConnectionMutation( + projectScope: ProjectConnectionScope, +) { + const queryClient = useQueryClient(); + return useMutation({ + mutationFn: (input: ProjectConnectionDraft & { id: string }) => + updateProjectConnection(input), + onSettled: async () => { + await queryClient.invalidateQueries({ + queryKey: projectConnectionsQueryKey(projectScope), + }); + }, + }); +} + +export function useTestProjectConnectionMutation( + projectScope: ProjectConnectionScope, +) { + const queryClient = useQueryClient(); + return useMutation({ + mutationFn: (connectionId: string) => + testProjectConnection(projectScope, connectionId), + onSettled: async () => { + await queryClient.invalidateQueries({ + queryKey: projectConnectionsQueryKey(projectScope), + }); + }, + }); +} + +export function useDeleteProjectConnectionMutation( + projectScope: ProjectConnectionScope, +) { + const queryClient = useQueryClient(); + return useMutation({ + mutationFn: (connectionId: string) => + deleteProjectConnection(projectScope, connectionId), + onSettled: async () => { + await queryClient.invalidateQueries({ + queryKey: projectConnectionsQueryKey(projectScope), + }); + }, + }); +} diff --git a/desktop/src/features/projects/ui/ProjectConnectionsPanel.tsx b/desktop/src/features/projects/ui/ProjectConnectionsPanel.tsx new file mode 100644 index 0000000000..f762bcd07a --- /dev/null +++ b/desktop/src/features/projects/ui/ProjectConnectionsPanel.tsx @@ -0,0 +1,708 @@ +import { + ChevronDown, + KeyRound, + Link2, + LoaderCircle, + Pencil, + Plus, + RefreshCw, + Trash2, + Wrench, + XCircle, +} from "lucide-react"; +import * as React from "react"; +import { toast } from "sonner"; + +import { + useCreateProjectConnectionMutation, + useDeleteProjectConnectionMutation, + useProjectConnectionsQuery, + useTestProjectConnectionMutation, + useUpdateProjectConnectionMutation, +} from "@/features/projects/projectConnectionHooks"; +import type { + ProjectConnection, + ProjectConnectionDraft, + ProjectConnectionHealthStatus, +} from "@/shared/api/tauriProjectConnections"; +import type { ProjectConnectionScope } from "@/shared/api/projectConnectionTypes"; +import { + AlertDialog, + AlertDialogAction, + AlertDialogCancel, + AlertDialogContent, + AlertDialogDescription, + AlertDialogFooter, + AlertDialogHeader, + AlertDialogTitle, +} from "@/shared/ui/alert-dialog"; +import { Button } from "@/shared/ui/button"; +import { Checkbox } from "@/shared/ui/checkbox"; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, +} from "@/shared/ui/dialog"; +import { Input } from "@/shared/ui/input"; +import { Textarea } from "@/shared/ui/textarea"; +import { + PROJECT_DETAIL_PANEL_CLASS, + PROJECT_DETAIL_PANEL_MESSAGE_CLASS, +} from "./projectPanelStyles"; +import { buildProjectConnectionSecretChanges } from "./projectConnectionSecrets"; + +const HEALTH_COPY: Record< + ProjectConnectionHealthStatus, + { label: string; className: string } +> = { + ready: { + label: "Tools found", + className: "bg-emerald-500/10 text-emerald-700 dark:text-emerald-300", + }, + not_tested: { + label: "Not tested", + className: "bg-muted text-muted-foreground", + }, + check_needed: { + label: "Check needed", + className: "bg-amber-500/10 text-amber-700 dark:text-amber-300", + }, + sign_in_required: { + label: "Sign-in required", + className: "bg-amber-500/10 text-amber-700 dark:text-amber-300", + }, + missing_access: { + label: "Missing access", + className: "bg-amber-500/10 text-amber-700 dark:text-amber-300", + }, + unavailable: { + label: "Unavailable", + className: "bg-destructive/10 text-destructive", + }, +}; + +type SecretRow = { id: string; key: string; value: string }; + +function emptySecretRow(): SecretRow { + return { id: crypto.randomUUID(), key: "", value: "" }; +} + +function capabilityLabel(capability: string) { + return capability + .replace(/^mcp\.tool\./, "") + .replaceAll("_", " ") + .replace(/\b\w/g, (letter) => letter.toUpperCase()); +} + +function formatVerificationTime(timestamp: string | null) { + if (!timestamp) return "Never tested"; + const date = new Date(timestamp); + return Number.isNaN(date.valueOf()) + ? "Last test unavailable" + : `Tested ${date.toLocaleString()}`; +} + +function ConnectionHealthBadge({ + status, +}: { + status: ProjectConnectionHealthStatus; +}) { + const copy = HEALTH_COPY[status]; + return ( + + {copy.label} + + ); +} + +function ConnectionDialog({ + connection, + onOpenChange, + onSave, + open, + pending, + projectScope, +}: { + connection: ProjectConnection | null; + onOpenChange: (open: boolean) => void; + onSave: (input: ProjectConnectionDraft & { id?: string }) => Promise; + open: boolean; + pending: boolean; + projectScope: ProjectConnectionScope; +}) { + const [name, setName] = React.useState(""); + const [provider, setProvider] = React.useState(""); + const [command, setCommand] = React.useState(""); + const [argsText, setArgsText] = React.useState(""); + const [showTechnicalDetails, setShowTechnicalDetails] = React.useState(false); + const [secrets, setSecrets] = React.useState([]); + const [removedEnvKeys, setRemovedEnvKeys] = React.useState([]); + const [trusted, setTrusted] = React.useState(false); + const [error, setError] = React.useState(null); + + React.useEffect(() => { + if (!open) { + setName(""); + setProvider(""); + setCommand(""); + setArgsText(""); + setSecrets([]); + setRemovedEnvKeys([]); + setTrusted(false); + setError(null); + return; + } + setName(connection?.name ?? ""); + setProvider(connection?.provider ?? ""); + setCommand(connection?.command ?? ""); + setArgsText(connection?.args.join("\n") ?? ""); + setSecrets( + connection?.envKeys.map((key) => ({ + id: crypto.randomUUID(), + key, + value: "", + })) ?? [emptySecretRow()], + ); + setRemovedEnvKeys([]); + setShowTechnicalDetails(Boolean(connection)); + setTrusted(Boolean(connection)); + setError(null); + }, [connection, open]); + + const canSave = + !pending && + name.trim().length > 0 && + provider.trim().length > 0 && + command.trim().length > 0; + const canSubmit = canSave && trusted; + + async function handleSubmit(event: React.FormEvent) { + event.preventDefault(); + if (!canSubmit) return; + const secretChanges = buildProjectConnectionSecretChanges( + secrets, + connection?.envKeys ?? [], + removedEnvKeys, + ); + if (!secretChanges.ok) { + setError(secretChanges.error); + return; + } + setError(null); + try { + await onSave({ + ...(connection ? { id: connection.id } : {}), + projectScope, + name: name.trim(), + provider: provider.trim(), + command: command.trim(), + args: argsText + .split("\n") + .map((arg) => arg.trim()) + .filter(Boolean), + env: secretChanges.env, + removeEnvKeys: secretChanges.removeEnvKeys, + executionAcknowledged: trusted, + }); + onOpenChange(false); + } catch (cause) { + setError( + cause instanceof Error + ? cause.message + : "Couldn't save this connection. Check the details and try again.", + ); + } + } + + return ( + + +
+ + + {connection ? "Edit connection" : "Add connection"} + + + {connection + ? "Save changes to this Project connection. Test it again after changing how it runs." + : "Save a local MCP connection for this Project. Secret values stay outside portable agent configuration."} + + +
+
+ + setName(event.target.value)} + placeholder="Analytics" + value={name} + /> +
+
+ + setProvider(event.target.value)} + placeholder="Google Analytics" + value={provider} + /> +
+
+ + { + setCommand(event.target.value); + setTrusted(false); + }} + placeholder="/absolute/path/to/mcp-server" + spellCheck={false} + value={command} + /> +

+ Enter the executable's absolute path. Buzz runs it directly + without a shell. +

+
+ + {showTechnicalDetails ? ( +
+
+ +