Skip to content

Commit ac5a186

Browse files
mahanticodex
andauthored
feat(desktop): add persistent Bestie experience (#7223)
## Summary - add a persistent, community-scoped Bestie designation for local managed agents - surface the designated agent in the sidebar, agent library, profile actions, message toolbar, and draggable floating shortcut - bloom the floating shortcut into a lightweight compact composer that reuses the normal DM timeline, reactions, presence, and send behavior - support message handoff with a bounded snapshot and a full Buzz thread link so the agent can retrieve the complete conversation ## UX details - the floating avatar and expanded panel stay above app chrome and drag as one aligned surface - closing the expanded panel returns it to its top-right anchor - each mini-composer opening starts visually fresh while messages sent during that opening remain conversational - the designated Bestie's duplicate DM entry is hidden from the regular DM list - Bestie actions are suppressed inside the mini timeline to avoid recursive handoff ## Reliability and maintainability - preserve existing retention database paths across upgrades - serialize assignment and deletion, clearing matching assignments across community scopes before an agent is removed - fence async conversation resolution against workspace and assignment changes - validate stale assignments against existing local agents before hiding DMs - share lightweight assignment state across agent cards and keep protected-feature behavior out of the shared timeline API ## Testing - `pnpm --dir desktop test` — 5,886 tests passed - `pnpm --dir desktop exec tsc --noEmit` - `pnpm --dir desktop exec biome check ...` - `cargo clippy --manifest-path desktop/src-tauri/Cargo.toml --all-targets -- -D warnings` - focused native retention and Bestie assignment/command tests — 34 passed - `VITE_BUZZ_BESTIE=1 pnpm --dir desktop build:e2e` - `VITE_BUZZ_BESTIE=1 pnpm --dir desktop exec playwright test --project=smoke tests/e2e/bestie.spec.ts` - pre-commit and differential pre-push hooks ## Rollout The UI remains gated by the `bestie` build feature. Screenshots covering setup, empty, assigned, floating, and message-handoff states are included in the PR discussion. --------- Signed-off-by: Arjun Mahanti <[email protected]> Co-authored-by: Codex <[email protected]>
1 parent 6f60932 commit ac5a186

43 files changed

Lines changed: 3279 additions & 41 deletions

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎desktop/.env.e2e‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
VITE_BUZZ_BESTIE=1

‎desktop/playwright.config.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -41,6 +41,7 @@ export default defineConfig({
4141
"**/hosted-communities-settings-screenshots.spec.ts",
4242
"**/invites-settings-screenshots.spec.ts",
4343
"**/messaging.spec.ts",
44+
"**/bestie.spec.ts",
4445
"**/message-feedback-snapshots.spec.ts",
4546
"**/message-copy-link.spec.ts",
4647
"**/custom-emoji.spec.ts",

‎desktop/src-tauri/src/commands/agents.rs‎

Lines changed: 37 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -6,14 +6,16 @@ use super::managed_agent_definition::validate_create_definition;
66
use crate::{
77
app_state::AppState,
88
managed_agents::{
9+
bestie_assignment::{recover_pending_assignment_cleanup, with_agent_assignments_cleared},
910
build_managed_agent_summary, current_instance_id, ensure_persona_is_active,
1011
find_managed_agent_mut, load_managed_agents, load_personas, load_teams,
11-
managed_agent_avatar_url, normalize_agent_args, resolve_provider_binary,
12-
save_managed_agents, start_managed_agent_process, stop_managed_agent_process,
13-
stop_managed_agent_workspace_pair, sync_managed_agent_processes, try_regenerate_nest,
14-
validate_provider_config, BackendKind, CreateManagedAgentRequest,
15-
CreateManagedAgentResponse, ManagedAgentRecord, ManagedAgentSummary, RelayMeshConfig,
16-
DEFAULT_ACP_COMMAND, DEFAULT_AGENT_PARALLELISM, DEFAULT_AGENT_TURN_TIMEOUT_SECONDS,
12+
managed_agent_avatar_url, managed_agents_base_dir, normalize_agent_args,
13+
resolve_provider_binary, save_managed_agents, start_managed_agent_process,
14+
stop_managed_agent_process, stop_managed_agent_workspace_pair,
15+
sync_managed_agent_processes, try_regenerate_nest, validate_provider_config, BackendKind,
16+
CreateManagedAgentRequest, CreateManagedAgentResponse, ManagedAgentRecord,
17+
ManagedAgentSummary, RelayMeshConfig, DEFAULT_ACP_COMMAND, DEFAULT_AGENT_PARALLELISM,
18+
DEFAULT_AGENT_TURN_TIMEOUT_SECONDS,
1719
},
1820
relay::relay_ws_url_with_override,
1921
util::now_iso,
@@ -1087,6 +1089,20 @@ pub async fn stop_managed_agent(
10871089

10881090
// Async so the blocking body (disk reads/writes, process termination, keyring
10891091
// delete, nest regeneration) runs off the main UI thread via spawn_blocking.
1092+
fn run_managed_agent_deletion<T>(
1093+
base_dir: &std::path::Path,
1094+
pubkey: &str,
1095+
records: &mut Vec<ManagedAgentRecord>,
1096+
delete: impl FnOnce(&mut Vec<ManagedAgentRecord>) -> Result<T, String>,
1097+
) -> Result<T, String> {
1098+
recover_pending_assignment_cleanup(base_dir, |pending_pubkey| {
1099+
records
1100+
.iter()
1101+
.any(|record| record.pubkey.eq_ignore_ascii_case(pending_pubkey))
1102+
})?;
1103+
with_agent_assignments_cleared(base_dir, pubkey, || delete(records))
1104+
}
1105+
10901106
#[tauri::command]
10911107
pub async fn delete_managed_agent(
10921108
pubkey: String,
@@ -1102,6 +1118,12 @@ pub async fn delete_managed_agent(
11021118
.lock()
11031119
.map_err(|error| error.to_string())?;
11041120
let mut records = load_managed_agents(&app)?;
1121+
let base_dir = managed_agents_base_dir(&app)?;
1122+
recover_pending_assignment_cleanup(&base_dir, |pending_pubkey| {
1123+
records
1124+
.iter()
1125+
.any(|record| record.pubkey.eq_ignore_ascii_case(pending_pubkey))
1126+
})?;
11051127
let mut runtimes = state
11061128
.managed_agent_processes
11071129
.lock()
@@ -1135,16 +1157,17 @@ pub async fn delete_managed_agent(
11351157
}
11361158
}
11371159

1138-
if let Some(record) = records.iter_mut().find(|record| record.pubkey == pubkey) {
1139-
stop_managed_agent_process(&app, record, &mut runtimes)?;
1140-
}
1141-
state.clear_agent_session_caches(&pubkey);
1142-
let initial_len = records.len();
1143-
records.retain(|record| record.pubkey != pubkey);
1144-
if records.len() == initial_len {
1160+
if !records.iter().any(|record| record.pubkey == pubkey) {
11451161
return Err(format!("agent {pubkey} not found"));
11461162
}
1147-
save_managed_agents(&app, &records)?;
1163+
run_managed_agent_deletion(&base_dir, &pubkey, &mut records, |records| {
1164+
if let Some(record) = records.iter_mut().find(|record| record.pubkey == pubkey) {
1165+
stop_managed_agent_process(&app, record, &mut runtimes)?;
1166+
}
1167+
state.clear_agent_session_caches(&pubkey);
1168+
records.retain(|record| record.pubkey != pubkey);
1169+
save_managed_agents(&app, records)
1170+
})?;
11481171
crate::managed_agents::delete_agent_key(&pubkey);
11491172
// Tombstone after confirmed removal (inside lock; every published
11501173
// agent tombstones). The NIP-IA kind:9035 archive request — which

‎desktop/src-tauri/src/commands/agents_tests.rs‎

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -188,6 +188,45 @@ fn deploy_resolver_inherits_global_when_definition_blank() {
188188
);
189189
}
190190

191+
#[test]
192+
fn production_delete_orchestration_restores_bestie_when_agent_save_fails() {
193+
use crate::managed_agents::{
194+
bestie_assignment::{assignment_matches, replace_assignment},
195+
retention::open_retention_db,
196+
};
197+
198+
let dir = tempfile::tempdir().unwrap_or_else(|error| panic!("temp dir: {error}"));
199+
let retention_dir = dir.path().join("retention");
200+
std::fs::create_dir_all(&retention_dir)
201+
.unwrap_or_else(|error| panic!("create retention dir: {error}"));
202+
let db_path = retention_dir.join("owner.db");
203+
let pubkey = "a".repeat(64);
204+
replace_assignment(
205+
&mut open_retention_db(&db_path)
206+
.unwrap_or_else(|error| panic!("open assignment DB: {error}")),
207+
&pubkey,
208+
)
209+
.unwrap_or_else(|error| panic!("seed assignment: {error}"));
210+
let mut record = bare_agent_record(None, None, None);
211+
record.pubkey.clone_from(&pubkey);
212+
let mut records = vec![record];
213+
214+
let result = run_managed_agent_deletion(dir.path(), &pubkey, &mut records, |_records| {
215+
Err::<(), _>("injected managed-agent save failure".to_string())
216+
});
217+
218+
assert_eq!(
219+
result,
220+
Err("injected managed-agent save failure".to_string())
221+
);
222+
assert!(assignment_matches(
223+
&open_retention_db(&db_path)
224+
.unwrap_or_else(|error| panic!("reopen assignment DB: {error}")),
225+
&pubkey,
226+
)
227+
.unwrap_or_else(|error| panic!("read restored assignment: {error}")));
228+
}
229+
191230
/// Deploy resolver falls back to global when both definition and record have none.
192231
#[test]
193232
fn deploy_resolver_falls_back_to_global_when_definition_and_record_have_none() {
Lines changed: 218 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,218 @@
1+
use std::sync::atomic::Ordering;
2+
3+
use tauri::{AppHandle, State};
4+
5+
use crate::{
6+
app_state::AppState,
7+
managed_agents::{
8+
bestie_assignment::{
9+
assignment_matches, clear_assignment, get_assignment,
10+
recover_pending_assignment_cleanup, replace_assignment, BestieAssignment,
11+
},
12+
load_managed_agents, managed_agents_base_dir,
13+
retention::{active_retention_scope, open_retention_db, RetentionScope},
14+
BackendKind, ManagedAgentRecord,
15+
},
16+
models::ChannelInfo,
17+
};
18+
19+
fn canonical_relay(relay_url: &str) -> Result<String, String> {
20+
buzz_core_pkg::relay::normalize_relay_url(relay_url).map_err(|error| error.to_string())
21+
}
22+
23+
fn assert_expected_scope(
24+
scope: &RetentionScope,
25+
expected_relay_url: Option<&str>,
26+
expected_signer_pubkey: Option<&str>,
27+
) -> Result<(), String> {
28+
if let Some(expected) = expected_relay_url {
29+
if canonical_relay(expected)? != canonical_relay(&scope.relay_url)? {
30+
return Err("active community changed while resolving Bestie".to_string());
31+
}
32+
}
33+
if let Some(expected) = expected_signer_pubkey {
34+
if expected.trim().to_ascii_lowercase() != scope.owner_keys.public_key().to_hex() {
35+
return Err("active identity changed while resolving Bestie".to_string());
36+
}
37+
}
38+
Ok(())
39+
}
40+
41+
fn validate_agent_pubkey(pubkey: &str) -> Result<String, String> {
42+
let normalized = pubkey.trim().to_ascii_lowercase();
43+
if normalized.len() != 64
44+
|| !normalized
45+
.chars()
46+
.all(|character| character.is_ascii_hexdigit())
47+
{
48+
return Err("Bestie agent pubkey must be 64 hexadecimal characters".to_string());
49+
}
50+
Ok(normalized)
51+
}
52+
53+
fn require_eligible_local_agent(
54+
records: &[ManagedAgentRecord],
55+
pubkey: &str,
56+
) -> Result<(), String> {
57+
let record = records
58+
.iter()
59+
.find(|record| record.pubkey.eq_ignore_ascii_case(pubkey))
60+
.ok_or_else(|| "assigned Bestie agent no longer exists on this device".to_string())?;
61+
if record.backend != BackendKind::Local {
62+
return Err("only a local managed agent can be your Bestie".to_string());
63+
}
64+
Ok(())
65+
}
66+
67+
fn recover_pending_cleanup(app: &AppHandle, records: &[ManagedAgentRecord]) -> Result<(), String> {
68+
recover_pending_assignment_cleanup(&managed_agents_base_dir(app)?, |pending_pubkey| {
69+
records
70+
.iter()
71+
.any(|record| record.pubkey.eq_ignore_ascii_case(pending_pubkey))
72+
})
73+
}
74+
75+
#[tauri::command]
76+
pub fn get_bestie_assignment(
77+
expected_relay_url: Option<String>,
78+
expected_signer_pubkey: Option<String>,
79+
app: AppHandle,
80+
state: State<'_, AppState>,
81+
) -> Result<Option<BestieAssignment>, String> {
82+
let scope = active_retention_scope(&app, &state)?;
83+
assert_expected_scope(
84+
&scope,
85+
expected_relay_url.as_deref(),
86+
expected_signer_pubkey.as_deref(),
87+
)?;
88+
let _store_guard = state
89+
.managed_agents_store_lock
90+
.lock()
91+
.map_err(|error| error.to_string())?;
92+
let records = load_managed_agents(&app)?;
93+
recover_pending_cleanup(&app, &records)?;
94+
let conn = open_retention_db(&scope.db_path)?;
95+
get_assignment(&conn)
96+
}
97+
98+
#[tauri::command]
99+
pub fn assign_bestie(
100+
agent_pubkey: String,
101+
expected_relay_url: Option<String>,
102+
expected_signer_pubkey: Option<String>,
103+
app: AppHandle,
104+
state: State<'_, AppState>,
105+
) -> Result<BestieAssignment, String> {
106+
let pubkey = validate_agent_pubkey(&agent_pubkey)?;
107+
let scope = active_retention_scope(&app, &state)?;
108+
assert_expected_scope(
109+
&scope,
110+
expected_relay_url.as_deref(),
111+
expected_signer_pubkey.as_deref(),
112+
)?;
113+
let _store_guard = state
114+
.managed_agents_store_lock
115+
.lock()
116+
.map_err(|error| error.to_string())?;
117+
let records = load_managed_agents(&app)?;
118+
recover_pending_cleanup(&app, &records)?;
119+
require_eligible_local_agent(&records, &pubkey)?;
120+
let mut conn = open_retention_db(&scope.db_path)?;
121+
replace_assignment(&mut conn, &pubkey)
122+
}
123+
124+
#[tauri::command]
125+
pub fn clear_bestie_assignment(
126+
expected_relay_url: Option<String>,
127+
expected_signer_pubkey: Option<String>,
128+
app: AppHandle,
129+
state: State<'_, AppState>,
130+
) -> Result<(), String> {
131+
let scope = active_retention_scope(&app, &state)?;
132+
assert_expected_scope(
133+
&scope,
134+
expected_relay_url.as_deref(),
135+
expected_signer_pubkey.as_deref(),
136+
)?;
137+
let _store_guard = state
138+
.managed_agents_store_lock
139+
.lock()
140+
.map_err(|error| error.to_string())?;
141+
let records = load_managed_agents(&app)?;
142+
recover_pending_cleanup(&app, &records)?;
143+
let mut conn = open_retention_db(&scope.db_path)?;
144+
clear_assignment(&mut conn)
145+
}
146+
147+
#[tauri::command]
148+
pub async fn resolve_bestie_conversation(
149+
expected_relay_url: Option<String>,
150+
expected_signer_pubkey: Option<String>,
151+
app: AppHandle,
152+
state: State<'_, AppState>,
153+
) -> Result<ChannelInfo, String> {
154+
let generation = state.workspace_apply_generation.load(Ordering::Acquire);
155+
let scope = active_retention_scope(&app, &state)?;
156+
assert_expected_scope(
157+
&scope,
158+
expected_relay_url.as_deref(),
159+
expected_signer_pubkey.as_deref(),
160+
)?;
161+
let assignment = {
162+
let _store_guard = state
163+
.managed_agents_store_lock
164+
.lock()
165+
.map_err(|error| error.to_string())?;
166+
let records = load_managed_agents(&app)?;
167+
recover_pending_cleanup(&app, &records)?;
168+
let conn = open_retention_db(&scope.db_path)?;
169+
let assignment = get_assignment(&conn)?
170+
.ok_or_else(|| "choose an agent before opening Bestie".to_string())?;
171+
require_eligible_local_agent(&records, &assignment.agent_pubkey)?;
172+
assignment
173+
};
174+
175+
let owner_pubkey = scope.owner_keys.public_key().to_hex();
176+
let channel = super::dms::open_dm_with_scope(
177+
vec![assignment.agent_pubkey.clone()],
178+
Some(&scope.relay_url),
179+
Some(&owner_pubkey),
180+
&state,
181+
)
182+
.await?;
183+
184+
if state.workspace_apply_generation.load(Ordering::Acquire) != generation {
185+
return Err("active workspace changed while resolving Bestie".to_string());
186+
}
187+
let current_scope = active_retention_scope(&app, &state)?;
188+
assert_expected_scope(&current_scope, Some(&scope.relay_url), Some(&owner_pubkey))?;
189+
let conn = open_retention_db(&scope.db_path)?;
190+
if !assignment_matches(&conn, &assignment.agent_pubkey)? {
191+
return Err("Bestie assignment changed while opening the conversation".to_string());
192+
}
193+
Ok(channel)
194+
}
195+
196+
#[cfg(test)]
197+
mod tests {
198+
use super::*;
199+
200+
#[test]
201+
fn relay_scope_accepts_runtime_equivalences() {
202+
assert_eq!(
203+
canonical_relay(" WSS://LOCALHOST:443/ ")
204+
.unwrap_or_else(|error| panic!("canonical relay: {error}")),
205+
"wss://127.0.0.1"
206+
);
207+
}
208+
209+
#[test]
210+
fn pubkeys_are_normalized_and_validated() {
211+
assert_eq!(
212+
validate_agent_pubkey(&"A".repeat(64))
213+
.unwrap_or_else(|error| panic!("valid pubkey: {error}")),
214+
"a".repeat(64)
215+
);
216+
assert!(validate_agent_pubkey("short").is_err());
217+
}
218+
}

0 commit comments

Comments
 (0)