Skip to content

Commit 5a3b817

Browse files
authored
fix(desktop): refresh cached channel member names (#2258)
1 parent e9188c0 commit 5a3b817

10 files changed

Lines changed: 471 additions & 31 deletions

File tree

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

Lines changed: 29 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@ use serde::Deserialize;
55
use tauri::{AppHandle, State};
66

77
use super::agent_model_process::run_agent_models_command;
8+
use super::agent_update_rollback::{rollback_failed_agent_update, AgentUpdateRollback};
89

910
use crate::{
1011
app_state::AppState,
@@ -778,7 +779,7 @@ pub async fn update_managed_agent(
778779
state: State<'_, AppState>,
779780
) -> Result<UpdateManagedAgentResponse, String> {
780781
// Phase 1: local save (synchronous, under lock)
781-
let (summary, sync_params) = {
782+
let (summary, sync_params, rollback) = {
782783
let _store_guard = state
783784
.managed_agents_store_lock
784785
.lock()
@@ -795,6 +796,7 @@ pub async fn update_managed_agent(
795796
}
796797

797798
let record = find_managed_agent_mut(&mut records, &input.pubkey)?;
799+
let previous_record = record.clone();
798800

799801
let mut name_changed = false;
800802
if let Some(name_update) = input.name {
@@ -938,37 +940,39 @@ pub async fn update_managed_agent(
938940
let personas = load_personas(&app).unwrap_or_default();
939941
build_managed_agent_summary(&app, record, &runtimes, &personas)?
940942
};
941-
(summary, sync_params)
943+
let rollback = name_changed.then(|| AgentUpdateRollback::new(previous_record, record));
944+
(summary, sync_params, rollback)
942945
}; // lock dropped here
943946

944947
try_regenerate_nest(&app);
945948

946-
// Phase 2: relay profile sync (async, best-effort, outside lock)
947-
let profile_sync_error =
948-
if let Some((agent_keys, relay_url, display_name, avatar_url, auth_tag)) = sync_params {
949-
match sync_managed_agent_profile(
950-
&state,
951-
&relay_url,
952-
&agent_keys,
953-
&display_name,
954-
avatar_url.as_deref(),
955-
auth_tag.as_deref(),
956-
)
957-
.await
958-
{
959-
Ok(()) => None,
960-
Err(e) => {
961-
eprintln!("buzz-desktop: relay profile sync failed after rename: {e}");
962-
Some(e)
963-
}
964-
}
965-
} else {
966-
None
967-
};
949+
// Phase 2: relay profile sync (async, outside lock). A rename is committed
950+
// only when this succeeds; otherwise restore the complete pre-edit record
951+
// so Desktop and the relay keep one authoritative name.
952+
if let Some((agent_keys, relay_url, display_name, avatar_url, auth_tag)) = sync_params {
953+
if let Err(sync_error) = sync_managed_agent_profile(
954+
&state,
955+
&relay_url,
956+
&agent_keys,
957+
&display_name,
958+
avatar_url.as_deref(),
959+
auth_tag.as_deref(),
960+
)
961+
.await
962+
{
963+
let rollback = rollback.ok_or_else(|| {
964+
"missing local rollback state after relay profile sync failure".to_string()
965+
})?;
966+
rollback_failed_agent_update(&app, &state, &summary.pubkey, rollback)?;
967+
return Err(format!(
968+
"Agent rename failed because its relay profile could not be updated. No changes were saved: {sync_error}"
969+
));
970+
}
971+
}
968972

969973
Ok(UpdateManagedAgentResponse {
970974
agent: summary,
971-
profile_sync_error,
975+
profile_sync_error: None,
972976
})
973977
}
974978

Lines changed: 197 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,197 @@
1+
use tauri::AppHandle;
2+
3+
use crate::{
4+
app_state::AppState,
5+
managed_agents::{
6+
load_managed_agents, save_managed_agents, try_regenerate_nest, ManagedAgentRecord,
7+
},
8+
};
9+
10+
#[derive(Debug)]
11+
pub(super) struct AgentUpdateRollback {
12+
attempted_record: ManagedAgentRecord,
13+
previous_record: ManagedAgentRecord,
14+
}
15+
16+
impl AgentUpdateRollback {
17+
pub(super) fn new(previous_record: ManagedAgentRecord, attempted: &ManagedAgentRecord) -> Self {
18+
Self {
19+
attempted_record: attempted.clone(),
20+
previous_record,
21+
}
22+
}
23+
}
24+
25+
fn copy_runtime_state(from: &ManagedAgentRecord, to: &mut ManagedAgentRecord) {
26+
to.runtime_pid = from.runtime_pid;
27+
to.backend = from.backend.clone();
28+
to.backend_agent_id.clone_from(&from.backend_agent_id);
29+
to.provider_binary_path
30+
.clone_from(&from.provider_binary_path);
31+
to.last_started_at.clone_from(&from.last_started_at);
32+
to.last_stopped_at.clone_from(&from.last_stopped_at);
33+
to.last_exit_code = from.last_exit_code;
34+
to.last_error.clone_from(&from.last_error);
35+
to.last_error_code = from.last_error_code;
36+
}
37+
38+
fn same_configuration(left: &ManagedAgentRecord, right: &ManagedAgentRecord) -> bool {
39+
let mut normalized_left = left.clone();
40+
copy_runtime_state(right, &mut normalized_left);
41+
normalized_left.updated_at.clone_from(&right.updated_at);
42+
normalized_left == *right
43+
}
44+
45+
fn restore_agent_update(
46+
records: &mut [ManagedAgentRecord],
47+
pubkey: &str,
48+
rollback: AgentUpdateRollback,
49+
) -> Result<(), String> {
50+
let current = records
51+
.iter_mut()
52+
.find(|record| record.pubkey == pubkey)
53+
.ok_or_else(|| format!("agent {pubkey} not found while rolling back failed rename"))?;
54+
55+
if !same_configuration(current, &rollback.attempted_record) {
56+
return Err(format!(
57+
"agent {pubkey} changed again before the failed rename could be rolled back"
58+
));
59+
}
60+
61+
let runtime_changed = {
62+
let mut attempted_with_current_runtime = rollback.attempted_record.clone();
63+
copy_runtime_state(current, &mut attempted_with_current_runtime);
64+
attempted_with_current_runtime != rollback.attempted_record
65+
};
66+
let mut restored = rollback.previous_record;
67+
copy_runtime_state(current, &mut restored);
68+
if runtime_changed {
69+
restored.updated_at.clone_from(&current.updated_at);
70+
}
71+
*current = restored;
72+
Ok(())
73+
}
74+
75+
pub(super) fn rollback_failed_agent_update(
76+
app: &AppHandle,
77+
state: &AppState,
78+
pubkey: &str,
79+
rollback: AgentUpdateRollback,
80+
) -> Result<(), String> {
81+
{
82+
let _store_guard = state
83+
.managed_agents_store_lock
84+
.lock()
85+
.map_err(|error| error.to_string())?;
86+
let mut records = load_managed_agents(app)?;
87+
restore_agent_update(&mut records, pubkey, rollback)?;
88+
save_managed_agents(app, &records)?;
89+
let restored = records
90+
.iter()
91+
.find(|record| record.pubkey == pubkey)
92+
.ok_or_else(|| format!("agent {pubkey} not found after failed rename rollback"))?;
93+
super::agents::retain_managed_agent_pending(app, state, restored);
94+
}
95+
try_regenerate_nest(app);
96+
Ok(())
97+
}
98+
99+
#[cfg(test)]
100+
mod tests {
101+
use super::*;
102+
103+
fn record(name: &str, updated_at: &str) -> ManagedAgentRecord {
104+
let mut record: ManagedAgentRecord = serde_json::from_str(
105+
r#"{
106+
"pubkey": "abcd1234",
107+
"name": "test-agent",
108+
"private_key_nsec": "nsec1fake",
109+
"relay_url": "wss://localhost:3000",
110+
"acp_command": "buzz-acp",
111+
"agent_command": "goose",
112+
"agent_args": [],
113+
"mcp_command": "",
114+
"turn_timeout_seconds": 320,
115+
"system_prompt": null,
116+
"model": null,
117+
"provider": null,
118+
"env_vars": {},
119+
"created_at": "2026-01-01T00:00:00Z",
120+
"updated_at": "2026-01-01T00:00:00Z",
121+
"last_started_at": null,
122+
"last_stopped_at": null,
123+
"last_exit_code": null,
124+
"last_error": null
125+
}"#,
126+
)
127+
.expect("sample managed agent record");
128+
record.name = name.to_string();
129+
record.updated_at = updated_at.to_string();
130+
record
131+
}
132+
133+
#[test]
134+
fn failed_profile_sync_restores_the_entire_agent_update() {
135+
let previous = record("Old name", "before");
136+
let mut attempted = previous.clone();
137+
attempted.name = "New name".to_string();
138+
attempted.model = Some("new-model".to_string());
139+
attempted.updated_at = "attempt".to_string();
140+
let rollback = AgentUpdateRollback::new(previous, &attempted);
141+
let mut records = vec![attempted];
142+
143+
restore_agent_update(&mut records, "abcd1234", rollback)
144+
.expect("matching attempted update rolls back");
145+
146+
assert_eq!(records[0].name, "Old name");
147+
assert_eq!(records[0].model, None);
148+
assert_eq!(records[0].updated_at, "before");
149+
}
150+
151+
#[test]
152+
fn failed_profile_sync_does_not_overwrite_a_newer_agent_update() {
153+
let previous = record("Old name", "before");
154+
let mut attempted = previous.clone();
155+
attempted.name = "New name".to_string();
156+
attempted.updated_at = "attempt".to_string();
157+
let rollback = AgentUpdateRollback::new(previous, &attempted);
158+
let mut newer = attempted;
159+
newer.name = "Newest name".to_string();
160+
newer.updated_at = "newer".to_string();
161+
let mut records = vec![newer];
162+
163+
let error = restore_agent_update(&mut records, "abcd1234", rollback)
164+
.expect_err("a concurrent update must not be overwritten");
165+
166+
assert!(error.contains("changed again"));
167+
assert_eq!(records[0].name, "Newest name");
168+
assert_eq!(records[0].updated_at, "newer");
169+
}
170+
171+
#[test]
172+
fn failed_profile_sync_preserves_runtime_churn_while_restoring_configuration() {
173+
let previous = record("Old name", "before");
174+
let mut attempted = previous.clone();
175+
attempted.name = "New name".to_string();
176+
attempted.model = Some("new-model".to_string());
177+
attempted.updated_at = "attempt".to_string();
178+
let rollback = AgentUpdateRollback::new(previous, &attempted);
179+
let mut churned = attempted;
180+
churned.runtime_pid = None;
181+
churned.last_stopped_at = Some("stopped".to_string());
182+
churned.last_exit_code = Some(1);
183+
churned.last_error = Some("harness exited".to_string());
184+
churned.updated_at = "runtime-change".to_string();
185+
let mut records = vec![churned];
186+
187+
restore_agent_update(&mut records, "abcd1234", rollback)
188+
.expect("runtime-only churn must not prevent rollback");
189+
190+
assert_eq!(records[0].name, "Old name");
191+
assert_eq!(records[0].model, None);
192+
assert_eq!(records[0].last_stopped_at.as_deref(), Some("stopped"));
193+
assert_eq!(records[0].last_exit_code, Some(1));
194+
assert_eq!(records[0].last_error.as_deref(), Some("harness exited"));
195+
assert_eq!(records[0].updated_at, "runtime-change");
196+
}
197+
}

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@ mod agent_model_process;
77
mod agent_models;
88
mod agent_providers;
99
mod agent_settings;
10+
mod agent_update_rollback;
1011
mod agents;
1112
mod canvas;
1213
mod channel_templates;

‎desktop/src-tauri/src/managed_agents/types.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -188,7 +188,7 @@ pub struct RelayAgentInfo {
188188
#[serde(default)]
189189
pub respond_to_allowlist: Vec<String>,
190190
}
191-
#[derive(Debug, Clone, Serialize, Deserialize)]
191+
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
192192
pub struct ManagedAgentRecord {
193193
pub pubkey: String,
194194
pub name: String,

‎desktop/src-tauri/src/relay.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -441,7 +441,7 @@ pub async fn sync_managed_agent_profile(
441441
if !response.status().is_success() {
442442
let msg = relay_error_message(response).await;
443443
return Err(format!(
444-
"Created the agent, but could not sync its profile metadata: {msg}"
444+
"Could not sync the agent's profile metadata: {msg}"
445445
));
446446
}
447447

‎desktop/src/features/agents/hooks.ts‎

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@ import {
1616
channelsQueryKey,
1717
upsertCachedChannelMember,
1818
} from "@/features/channels/hooks";
19+
import { updateCachedChannelMemberDisplayName } from "@/features/channels/channelMemberProfileCache";
1920
import { evictUsersBatchEntries } from "@/features/profile/hooks";
2021
import {
2122
createManagedAgent,
@@ -359,7 +360,7 @@ export function useUpdateManagedAgentMutation() {
359360

360361
return useMutation({
361362
mutationFn: (input: UpdateManagedAgentInput) => updateManagedAgent(input),
362-
onSuccess: (result) => {
363+
onSuccess: async (result, variables) => {
363364
queryClient.setQueryData<ManagedAgent[]>(
364365
managedAgentsQueryKey,
365366
(current) => {
@@ -369,6 +370,14 @@ export function useUpdateManagedAgentMutation() {
369370
);
370371
},
371372
);
373+
374+
if (variables.name !== undefined && !result.profileSyncError) {
375+
await updateCachedChannelMemberDisplayName(
376+
queryClient,
377+
result.agent.pubkey,
378+
result.agent.name,
379+
);
380+
}
372381
},
373382
onSettled: async (_data, _error, variables) => {
374383
// Backend republishes kind:0 on a name change (sync_managed_agent_profile),

‎desktop/src/features/agents/ui/AgentInstanceEditDialog.tsx‎

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -726,9 +726,6 @@ export function AgentInstanceEditDialog({
726726
autoRestartOnConfigChange,
727727
);
728728
}
729-
if (result.profileSyncError) {
730-
console.warn("Relay profile sync failed:", result.profileSyncError);
731-
}
732729
handleOpenChange(false);
733730
onUpdated?.(result.agent);
734731
// The auto-restart policy deliberately never fires for a stopped or

0 commit comments

Comments
 (0)