diff --git a/cli/docs/local-agent-bridge.md b/cli/docs/local-agent-bridge.md index c1ac7b002..7cabde1f6 100644 --- a/cli/docs/local-agent-bridge.md +++ b/cli/docs/local-agent-bridge.md @@ -16,6 +16,29 @@ requires explicit handoff mentions and warns against reciprocal loops. The Rust bridge is bundled with the Inline CLI and runs as one per-user background service; agent processes and project files remain on the user's computer. +## Updates and restarts + +The bridge applies a staged update once active work and pending publication +finish; open idle sessions do not block it, and there is no extra quiet period. +Automatic activations stay at least six hours apart. Running `inline update` by +hand asks the bridge to adopt the staged runtime at its next idle moment +instead, skipping that spacing but not the idle wait or the trial. Admission +closes atomically before the old runtime stops, so new work cannot race the +handoff. + +`inline bridge status` and `inline bridge doctor` show the running CLI version, +the retained supervisor's version, and pending updates or rollbacks. The binary +in the bridge's `bin` directory belongs to the supervisor; its `--version` can +differ from the runtime doing agent work. + +A deliberate `inline bridge stop` or `restart` during a candidate's startup +probation leaves that candidate available for retry. Crashes and failed health +checks still trigger rollback. A restart preserves native session bindings, +thread settings, and durable delivery records. Existing sessions reopen when +you next message them; input with an uncertain delivery is reconciled rather +than automatically sent again. Unsent input interrupted by a manual restart +asks you to resend it. + ## Setup Authenticate the provider's own CLI first, then run setup. If the Inline CLI is diff --git a/cli/docs/releases.md b/cli/docs/releases.md index b3fa83056..74fdbab15 100644 --- a/cli/docs/releases.md +++ b/cli/docs/releases.md @@ -135,8 +135,8 @@ native sessions and folders. Codex and Claude may replace an unavailable v1 session with a fresh one. OpenCode and Amp preserve an unavailable saved binding and ask the user to retry or explicitly start a new conversation with `/new`; old Amp adapter sessions cannot resume across processes. Turns v1 had -queued or was running get a "send it again" reply, and v1 approval and question -cards expire. Settings may reset to v2 defaults; migration +queued or was running get a "send it again" reply, and v1 approval, question, +and session-picker cards expire. Settings may reset to v2 defaults; migration does not require preserving every old setting. When a legacy binding matches the registered native session, its saved folder is retained and persisted for subsequent restarts. Explicit thread folder @@ -264,7 +264,7 @@ persisted policy and actual provider readiness after this new-binary restart. For an already supervised bridge, `inline bridge refresh --json` refreshes the retained parent from its committed, verified runtime. It never installs the invoking CLI. It returns `waiting_for_idle` while turns, queued inputs, questions, -approvals or the two-minute quiet period remain; retry later. It refuses pending +approvals or pending publication remain; retry later. It refuses pending activations and preserves configuration, authentication, receipt databases and runtime rollback history. An already current parent returns `up_to_date`. diff --git a/cli/src/bridge.rs b/cli/src/bridge.rs index 4fddd39b1..4a6d52139 100644 --- a/cli/src/bridge.rs +++ b/cli/src/bridge.rs @@ -3740,18 +3740,13 @@ fn opencode_native_for(version: &str) -> bool { async fn settle_v1_leftovers(bot: &InlineClient, store: &BridgeStore, installation_id: &str) { let result: Result<(), Box> = async { let installation_id = InstallationId::new(installation_id.to_owned())?; + store.expire_session_pickers_for_installation(&installation_id, now_seconds())?; store.stage_unfinished_inbound_for_installation( &installation_id, "bridge moved to v2 before the turn finished", "This didn't finish before the bridge was updated. Send it again if you still want it.", )?; - recover_provider_inbox( - bot, - store, - &installation_id, - InterruptionKind::BridgeRestart, - ) - .await + recover_provider_inbox(bot, store, &installation_id, InterruptionKind::BridgeUpdate).await } .await; if let Err(error) = result { diff --git a/cli/src/bridge/recovery.rs b/cli/src/bridge/recovery.rs index 7bfb9dffe..6d7d25a25 100644 --- a/cli/src/bridge/recovery.rs +++ b/cli/src/bridge/recovery.rs @@ -5,6 +5,7 @@ use super::*; #[derive(Clone, Copy, Debug)] pub(super) enum InterruptionKind { BridgeRestart, + BridgeUpdate, ProviderRestart, } @@ -12,6 +13,7 @@ impl InterruptionKind { fn failure(self) -> &'static str { match self { Self::BridgeRestart => "bridge process restarted during the turn", + Self::BridgeUpdate => "bridge moved to v2 before the turn finished", Self::ProviderRestart => "local agent disconnected during the turn", } } @@ -21,6 +23,9 @@ impl InterruptionKind { Self::BridgeRestart => { "This turn was interrupted when the bridge restarted. Send it again if you still want me to continue." } + Self::BridgeUpdate => { + "This didn't finish before the bridge was updated. Send it again if you still want it." + } Self::ProviderRestart => { "This turn was interrupted when the local agent disconnected. Send it again after the agent reconnects." } @@ -35,7 +40,13 @@ pub(super) async fn recover_provider_inbox( interruption: InterruptionKind, ) -> Result<(), Box> { store.recover_session_pickers(installation_id, now_seconds())?; - recover_session_picker_commands(bot, store, installation_id).await?; + recover_session_picker_commands( + bot, + store, + installation_id, + matches!(interruption, InterruptionKind::BridgeUpdate), + ) + .await?; for request in store .expire_open_command_choice_requests_for_installation(installation_id, now_seconds())? { diff --git a/cli/src/bridge/service.rs b/cli/src/bridge/service.rs index ee46aba1b..57c588654 100644 --- a/cli/src/bridge/service.rs +++ b/cli/src/bridge/service.rs @@ -440,6 +440,7 @@ pub(super) async fn stop_service( secrets: &AccountBridgeSecrets, installation: &ProviderInstallationConfig, ) -> Result> { + record_stop_intent(paths); #[cfg(target_os = "macos")] let mut stopped_cleanly = false; if let Ok(response) = control_request(paths, secrets, ControlCommand::Shutdown).await @@ -667,6 +668,7 @@ async fn restart_installed_service( refresh_systemd_user_unit(paths, account)?; let unit_name = systemd_unit_name(&account.service_label); run_systemctl(["--user", "enable", &unit_name])?; + record_stop_intent(paths); run_systemctl(["--user", "restart", &unit_name])?; } #[cfg(not(any(target_os = "macos", target_os = "linux")))] @@ -734,15 +736,20 @@ pub(super) async fn status( provider_detail(&response, &installation.installation_id); let provider_ready = matches!(provider_state, ProviderRuntimeState::Ready); let account_running = response.status == "running"; - let detail = response.detail.or(provider_connection_detail).or_else(|| { - (!provider_ready).then(|| { - format!( - "{} is {}", - installation.display_name, - provider_state.status() - ) - }) - }); + let detail = response + .detail + .clone() + .or(provider_connection_detail) + .or_else(|| { + (!provider_ready).then(|| { + format!( + "{} is {}", + installation.display_name, + provider_state.status() + ) + }) + }); + let detail = with_update_detail(paths, Some(&response.cli_version), detail); BridgeStatus { status: if account_running { provider_state.status().to_string() @@ -787,16 +794,41 @@ pub(super) async fn status( process_id: None, inline_connected: false, provider_ready: false, - detail: with_service_lifecycle_detail(if process_running { - Some(safe_diagnostic(&error.to_string())) - } else { - setup_required - }), + detail: with_service_lifecycle_detail(with_update_detail( + paths, + None, + if process_running { + Some(safe_diagnostic(&error.to_string())) + } else { + setup_required + }, + )), } } } } +fn record_stop_intent(paths: &BridgePaths) { + if let Err(error) = super::update_supervisor::request_stop(paths) { + // Stopping must remain possible when disk/journal access is broken. + log::warn!("could not record deliberate bridge stop: {}", error.stage()); + } +} + +fn with_update_detail( + paths: &BridgePaths, + version: Option<&str>, + detail: Option, +) -> Option { + match ( + detail, + super::update_supervisor::status_detail(paths, version), + ) { + (Some(detail), Some(update)) => Some(format!("{detail}; {update}")), + (detail, update) => detail.or(update), + } +} + /// Why a stopped service or agent will not come back until setup runs again. fn setup_required_detail( paths: &BridgePaths, diff --git a/cli/src/bridge/session_browser.rs b/cli/src/bridge/session_browser.rs index 85df2bf31..0743b3766 100644 --- a/cli/src/bridge/session_browser.rs +++ b/cli/src/bridge/session_browser.rs @@ -1788,9 +1788,12 @@ pub(super) async fn recover_session_picker_commands( bot: &InlineClient, store: &BridgeStore, installation_id: &InstallationId, + bridge_updated: bool, ) -> Result<(), Box> { for picker in store.session_picker_recovery_cards(installation_id)? { - if let Err(error) = repair_recovered_session_picker_card(bot, store, &picker).await { + if let Err(error) = + repair_recovered_session_picker_card(bot, store, &picker, bridge_updated).await + { eprintln!( "Could not repair an interrupted session picker card: {}", safe_diagnostic(&error.to_string()) @@ -1835,6 +1838,7 @@ async fn repair_recovered_session_picker_card( bot: &InlineClient, store: &BridgeStore, picker: &SessionPickerRecord, + bridge_updated: bool, ) -> Result<(), Box> { let message_id = picker.picker_message_id.ok_or_else(|| { io::Error::new( @@ -1843,6 +1847,12 @@ async fn repair_recovered_session_picker_card( ) })?; let (text, actions, terminal) = match picker.state { + SessionPickerState::Expired | SessionPickerState::Failed if bridge_updated => ( + "This session picker expired when the bridge was updated. Start a new thread with /new." + .to_string(), + MessageActions { rows: Vec::new() }, + true, + ), SessionPickerState::Retryable => { let (card, actions) = session_picker_record_card(picker)?; (card, actions, false) diff --git a/cli/src/bridge/update_activity.rs b/cli/src/bridge/update_activity.rs index 81f50687d..3c8363c42 100644 --- a/cli/src/bridge/update_activity.rs +++ b/cli/src/bridge/update_activity.rs @@ -5,7 +5,6 @@ use std::{ Arc, Mutex, OnceLock, atomic::{AtomicU64, Ordering}, }, - time::{Duration, Instant}, }; #[derive(Clone)] @@ -13,13 +12,10 @@ pub(crate) struct Activity(Arc>); struct State { active: usize, busy: HashSet, - last_work: Instant, - requested: Option, draining: bool, } pub(crate) struct Lease { activity: Activity, - work: bool, } pub(crate) struct BusyKey { activity: Activity, @@ -36,18 +32,16 @@ impl Activity { Self(Arc::new(Mutex::new(State { active: 0, busy: HashSet::new(), - last_work: Instant::now(), - requested: None, draining: false, }))) } pub fn enter(&self) -> Option { - self.reserve(true) + self.reserve() } pub fn maintenance(&self) -> Option { - self.reserve(false) + self.reserve() } - fn reserve(&self, work: bool) -> Option { + fn reserve(&self) -> Option { let mut state = self.0.lock().unwrap_or_else(|e| e.into_inner()); if state.draining { return None; @@ -55,7 +49,6 @@ impl Activity { state.active += 1; Some(Lease { activity: self.clone(), - work, }) } pub fn key(&self) -> BusyKey { @@ -70,24 +63,13 @@ impl Activity { pub fn cancel(&self) { let mut state = self.0.lock().unwrap_or_else(|e| e.into_inner()); state.draining = false; - state.requested = None; } pub fn prepare(&self) -> bool { - self.prepare_with_quiet(Duration::from_secs(120)) - } - fn prepare_with_quiet(&self, quiet: Duration) -> bool { let mut state = self.0.lock().unwrap_or_else(|e| e.into_inner()); - let now = Instant::now(); - let requested = *state.requested.get_or_insert(now); - let quiet = if now.duration_since(requested) >= Duration::from_secs(24 * 60 * 60) { - Duration::ZERO - } else { - quiet - }; - if state.active == 0 - && state.busy.is_empty() - && now.duration_since(state.last_work) >= quiet - { + // The admission lock and the work leases provide the handoff boundary. + // A time window also counts unrelated bot events as work, so an idle + // bridge could otherwise wait indefinitely on its own traffic. + if state.active == 0 && state.busy.is_empty() { state.draining = true; } state.draining @@ -97,21 +79,15 @@ impl Drop for Lease { fn drop(&mut self) { let mut state = self.activity.0.lock().unwrap_or_else(|e| e.into_inner()); state.active = state.active.saturating_sub(1); - if self.work { - state.last_work = Instant::now(); - } } } impl BusyKey { pub fn set(&self, busy: bool) { let mut state = self.activity.0.lock().unwrap_or_else(|e| e.into_inner()); - let changed = if busy { - state.busy.insert(self.id) + if busy { + state.busy.insert(self.id); } else { - state.busy.remove(&self.id) - }; - if changed { - state.last_work = Instant::now(); + state.busy.remove(&self.id); } } } @@ -125,10 +101,10 @@ impl Drop for BusyKey { mod tests { use super::*; #[test] - fn updater_housekeeping_does_not_prevent_a_quiet_handoff() { + fn finished_deliveries_and_housekeeping_do_not_delay_an_idle_handoff() { let activity = Activity::new(); - activity.0.lock().unwrap().last_work = Instant::now() - Duration::from_secs(180); for _ in 0..10 { + drop(activity.enter().unwrap()); drop(activity.maintenance().unwrap()); } assert!(activity.prepare()); @@ -139,13 +115,13 @@ mod tests { fn queued_work_and_questions_close_the_admission_race() { let activity = Activity::new(); let queued = activity.enter().unwrap(); - assert!(!activity.prepare_with_quiet(Duration::ZERO)); + assert!(!activity.prepare()); let question = activity.key(); question.set(true); drop(queued); - assert!(!activity.prepare_with_quiet(Duration::ZERO)); + assert!(!activity.prepare()); question.set(false); - assert!(activity.prepare_with_quiet(Duration::ZERO)); + assert!(activity.prepare()); assert!(activity.enter().is_none()); activity.cancel(); assert!(activity.enter().is_some()); diff --git a/cli/src/bridge/update_supervisor.rs b/cli/src/bridge/update_supervisor.rs index 85cf2975f..b5edcdea6 100644 --- a/cli/src/bridge/update_supervisor.rs +++ b/cli/src/bridge/update_supervisor.rs @@ -180,6 +180,63 @@ fn startup_path(paths: &BridgePaths) -> PathBuf { paths.root.join("startup.json") } +fn stop_path(paths: &BridgePaths) -> PathBuf { + paths.root.join("stop.json") +} + +/// Record the operator's intent before shutting down the child or OS service. +/// The selected hash scopes the request to this activation, and the next +/// supervisor consumes it before starting any work. +pub(super) fn request_stop(paths: &BridgePaths) -> Result<(), UpdateError> { + if enabled(paths) { + let state = read_activation(paths).map_err(journal_failure)?; + atomic_json(&stop_path(paths), &state.current.sha256)?; + } + Ok(()) +} + +fn stop_requested(paths: &BridgePaths, state: &Activation) -> bool { + read_json::(&stop_path(paths)).is_ok_and(|hash| hash == state.current.sha256) +} + +pub(super) fn status_detail(paths: &BridgePaths, running_version: Option<&str>) -> Option { + if !enabled(paths) { + return running_version.map(|version| format!("Runtime CLI: {version}")); + } + let state = match read_activation(paths) { + Ok(state) => state, + Err(_) => { + return Some("Bridge update state is unavailable; run `inline bridge doctor`".into()); + } + }; + let mut detail = match running_version { + Some(version) => format!("Runtime CLI: {version}"), + None => format!("Selected CLI: {}", state.current.version), + }; + if let Some(supervisor) = &state.supervisor { + detail.push_str(&format!("; supervisor CLI: {}", supervisor.version)); + } + match state.phase.as_str() { + "rolled_back" => detail.push_str(&format!( + "; update rolled back ({}); {} rejected candidate(s)", + state.failure.as_deref().unwrap_or("unknown failure"), + state.rejected.len(), + )), + "waiting_for_idle" | "trial" | "maintenance_required" => { + if let Some(candidate) = &state.candidate { + let phase = match state.phase.as_str() { + "trial" => "in probation", + "maintenance_required" => "requires storage maintenance", + _ => "waiting for active work to finish", + }; + detail.push_str(&format!("; update {} {phase}", candidate.version)); + } + } + _ => {} + } + Some(super::safe_diagnostic(&detail)) +} + pub(super) fn request_restart( paths: &BridgePaths, candidate: &Artifact, @@ -236,6 +293,11 @@ async fn start_selected( false, ) .await; + if stop_requested(paths, state) { + // Preserve the startup request so a deliberate restart can + // retry this exact candidate without quarantining it. + return result; + } let _ = fs::remove_file(startup_path(paths)); if let Ok(child) = result { return Ok(child); @@ -244,6 +306,9 @@ async fn start_selected( let _ = fs::remove_file(startup_path(paths)); } } + if stop_requested(paths, state) { + return Err(UpdateError::Busy); + } launch(&state.current, paths, store) } @@ -335,6 +400,9 @@ async fn local_trial( let deadline = tokio::time::Instant::now() + policy.deadline; let mut ready_since = None; loop { + if stop_path(paths).exists() { + return Err(UpdateError::Busy); + } if let Some(status) = child.try_wait()? { let setup = super::FailureLedger::service(paths) .load() @@ -377,6 +445,9 @@ async fn activate( policy: TrialPolicy, rollback: bool, ) -> Result { + if stop_requested(paths, state) { + return Err(UpdateError::Busy); + } update::validate_cached(store, &candidate)?; if candidate.minimum_reader_schema_version > state.current.bridge_schema_version { return Err(UpdateError::Verification("storage_maintenance_required")); @@ -389,9 +460,20 @@ async fn activate( } let mut failure = "candidate_launch"; for _ in 0..3 { + if stop_requested(paths, state) { + pending(state, Some(&candidate), "waiting_for_idle", paths)?; + return Err(UpdateError::Busy); + } match launch(&candidate, paths, store) { Ok(mut child) => { - match local_trial(&mut child, &candidate, paths, secrets, policy).await { + let trial = local_trial(&mut child, &candidate, paths, secrets, policy).await; + if stop_requested(paths, state) { + let _ = stop_with_timeout(&mut child, paths, secrets, policy.stop).await; + // Interrupted by the operator, not a failed health check. + pending(state, Some(&candidate), "waiting_for_idle", paths)?; + return Err(UpdateError::Busy); + } + match trial { Ok(()) => { let from = state.current.version.clone(); let mut committed = state.clone(); @@ -434,6 +516,10 @@ async fn activate( } tokio::time::sleep(policy.retry).await; } + if stop_requested(paths, state) { + pending(state, Some(&candidate), "waiting_for_idle", paths)?; + return Err(UpdateError::Busy); + } reject(state, &candidate, failure); // Recovery still runs if the disk became full/read-only during probation. // The persisted trial already identifies the old selection for a reboot. @@ -452,18 +538,26 @@ fn recover_interrupted(state: &mut Activation, paths: &BridgePaths, channel: &st if state.phase == "trial" && let Some(candidate) = state.candidate.clone() { - reject(state, &candidate, "interrupted_trial"); - // The persisted trial already selects the previous runtime. A - // full disk must not prevent that runtime from starting on reboot. - let _ = atomic_json(&journal(paths), state); - crate::telemetry::report_update( - "rolled_back", - channel, - &candidate.version, - &state.current.version, - "interrupted_trial", - ); + if stop_requested(paths, state) { + // The old selection is still authoritative. Retry a deliberately + // interrupted candidate normally on the next startup/idle handoff. + state.phase = "waiting_for_idle".into(); + let _ = atomic_json(&journal(paths), state); + } else { + reject(state, &candidate, "interrupted_trial"); + // The persisted trial already selects the previous runtime. A + // full disk must not prevent that runtime from starting on reboot. + let _ = atomic_json(&journal(paths), state); + crate::telemetry::report_update( + "rolled_back", + channel, + &candidate.version, + &state.current.version, + "interrupted_trial", + ); + } } + let _ = fs::remove_file(stop_path(paths)); } fn pending( @@ -720,6 +814,16 @@ pub(super) async fn run(config_path: PathBuf) -> Result<(), Box {} } + if stop_requested(&paths, &state) { + if let Some(child) = &mut child { + let _ = stop(child, &paths, &secrets).await; + } + if let Some(worker) = &mut worker { + let _ = worker.start_kill(); + let _ = worker.wait().await; + } + return Ok(()); + } let now = tokio::time::Instant::now(); if worker .as_mut() @@ -849,11 +953,14 @@ pub(super) async fn run(config_path: PathBuf) -> Result<(), Box child = Some(updated), + Err(_) if stop_requested(&paths, &state) => continue, Err(_) => { // A failed preflight or journal write must not // drop the still-working process handle. @@ -925,7 +1032,7 @@ pub(super) async fn run(config_path: PathBuf) -> Result<(), Box= next_start { + if child.is_none() && !parked && now >= next_start && !stop_requested(&paths, &state) { child = launch(&state.current, &paths, &store).ok().or_else(|| { recover_failed_launch( &mut state, @@ -1194,6 +1301,120 @@ mod tests { .unwrap(); } + #[tokio::test] + async fn deliberate_stop_during_probation_keeps_candidate_retryable_on_restart() { + let f = Fixture::new(); + let old = f.artifact("old"); + let candidate = f.artifact("healthy"); + let mut state = f.state(old.clone()); + atomic_json(&journal(&f.paths), &state).unwrap(); + request_restart(&f.paths, &candidate).unwrap(); + let stop_during_trial = async { + let deadline = tokio::time::Instant::now() + Duration::from_secs(3); + loop { + if fs::read_to_string(f.paths.root.join("trace")) + .is_ok_and(|trace| trace.contains("start healthy")) + { + request_stop(&f.paths).unwrap(); + break; + } + assert!( + tokio::time::Instant::now() < deadline, + "candidate never started" + ); + tokio::time::sleep(Duration::from_millis(5)).await; + } + }; + let (result, ()) = tokio::join!( + start_selected( + &mut state, + &f.paths, + &f.store, + &f.secrets, + "alpha", + TrialPolicy { + probation: Duration::from_secs(1), + ..QUICK + } + ), + stop_during_trial, + ); + assert!(matches!(result, Err(UpdateError::Busy))); + assert_eq!(state.current, old); + assert_eq!(state.phase, "waiting_for_idle"); + assert!(state.rejected.is_empty()); + assert!(state.failure.is_none()); + assert!(startup_path(&f.paths).is_file()); + assert_eq!( + fs::read_to_string(f.paths.root.join("trace")) + .unwrap() + .lines() + .collect::>(), + ["start healthy", "stop healthy"], + "a deliberate stop must not launch a fallback or retry behind the operator", + ); + + let mut restarted = read_activation(&f.paths).unwrap(); + recover_interrupted(&mut restarted, &f.paths, "alpha"); + assert!(!stop_path(&f.paths).exists()); + let mut child = start_selected( + &mut restarted, + &f.paths, + &f.store, + &f.secrets, + "alpha", + QUICK, + ) + .await + .unwrap(); + assert_eq!(restarted.current, candidate); + assert_eq!(restarted.phase, "committed"); + assert!(restarted.rejected.is_empty()); + f.assert_account_unchanged(); + stop_with_timeout(&mut child, &f.paths, &f.secrets, QUICK.stop) + .await + .unwrap(); + } + + #[test] + fn intentional_stop_survives_parent_exit_during_trial_without_quarantine() { + let f = Fixture::new(); + let old = f.artifact("old"); + let candidate = f.artifact("healthy"); + let mut state = f.state(old.clone()); + pending(&mut state, Some(&candidate), "trial", &f.paths).unwrap(); + request_stop(&f.paths).unwrap(); + let mut restarted = read_activation(&f.paths).unwrap(); + recover_interrupted(&mut restarted, &f.paths, "alpha"); + assert_eq!(restarted.current, old); + assert_eq!(restarted.candidate, Some(candidate)); + assert_eq!(restarted.phase, "waiting_for_idle"); + assert!(restarted.rejected.is_empty()); + assert!(restarted.failure.is_none()); + assert!(!stop_path(&f.paths).exists()); + f.assert_account_unchanged(); + } + + #[test] + fn status_distinguishes_running_runtime_parent_pending_and_rollback() { + let f = Fixture::new(); + let old = f.artifact("old"); + let mut candidate = f.artifact("healthy"); + candidate.version = "9.0.0".into(); + let mut state = f.state(old); + pending(&mut state, Some(&candidate), "waiting_for_idle", &f.paths).unwrap(); + let detail = status_detail(&f.paths, Some("8.0.0")).unwrap(); + assert!(detail.contains("Runtime CLI: 8.0.0")); + assert!(detail.contains("supervisor CLI:")); + assert!(detail.contains("update 9.0.0 waiting for active work to finish")); + reject(&mut state, &candidate, "candidate_exit"); + atomic_json(&journal(&f.paths), &state).unwrap(); + let detail = status_detail(&f.paths, None).unwrap(); + assert!(detail.contains("Selected CLI:")); + assert!(detail.contains("update rolled back (candidate_exit)")); + assert!(detail.contains("1 rejected candidate(s)")); + } + #[tokio::test] async fn update_trial_crashes_and_hangs_restore_working_runtime_without_restoring_old_data() { for mode in ["crash", "hang", "cannot_exec"] { diff --git a/cli/src/bridge/v2/corpus.rs b/cli/src/bridge/v2/corpus.rs index c5e6fddba..510cff589 100644 --- a/cli/src/bridge/v2/corpus.rs +++ b/cli/src/bridge/v2/corpus.rs @@ -138,6 +138,32 @@ fn transcripts(root: &Path) -> Vec { files } +fn validate_ranges(value: &Value, units: &[u16]) { + match value { + Value::Object(fields) => { + if let (Some(offset), Some(length)) = ( + fields.get("offset").and_then(Value::as_i64), + fields.get("length").and_then(Value::as_i64), + ) { + assert!(offset >= 0 && length >= 0); + let range = units + .get(offset as usize..(offset + length) as usize) + .expect("rich-text range exceeds the published text"); + String::from_utf16(range).expect("rich-text range splits a Unicode scalar"); + } + for value in fields.values() { + validate_ranges(value, units); + } + } + Value::Array(items) => { + for item in items { + validate_ranges(item, units); + } + } + _ => {} + } +} + #[test] #[ignore = "reads local transcripts; set INLINE_RENDER_CORPUS"] fn real_turns_render_within_inlines_limits() { @@ -185,6 +211,14 @@ fn real_turns_render_within_inlines_limits() { }; messages += 1; let size = Size::of(doc); + assert!( + !doc.text.contains('\0'), + "native database decoding stops at NUL" + ); + validate_ranges( + &serde_json::to_value(&doc.blocks).unwrap(), + &doc.text.encode_utf16().collect::>(), + ); assert!( size.fits(), "{} turn {turns_seen}: a message over Inline's limits: {size:?}", diff --git a/cli/src/bridge/v2/doc.rs b/cli/src/bridge/v2/doc.rs index b368e27ee..5538ec4f5 100644 --- a/cli/src/bridge/v2/doc.rs +++ b/cli/src/bridge/v2/doc.rs @@ -5,6 +5,7 @@ //! readable plain text and records each block's range as it goes. use inline_agent_bridge::harness::{FieldInput, QuestionForm}; +use inline_agent_bridge::sanitize_visible_text; use inline_protocol::proto; /// One message: fallback text plus structured blocks. @@ -23,7 +24,7 @@ impl Doc { /// Markdown, so headings, lists, code and links render. pub(crate) fn markdown(text: &str) -> Self { Self { - text: text.trim().to_owned(), + text: sanitize_visible_text(text).trim().to_owned(), blocks: Vec::new(), markdown: true, } @@ -41,6 +42,7 @@ impl Doc { /// Adds a paragraph after the existing content. pub(crate) fn append_paragraph(&mut self, text: &str) { + let text = sanitize_visible_text(text); if text.trim().is_empty() { return; } @@ -48,11 +50,11 @@ impl Doc { self.text.push('\n'); } if self.markdown { - self.text.push_str(text); + self.text.push_str(&text); return; } let offset = self.text.encode_utf16().count() as i64; - self.text.push_str(text); + self.text.push_str(&text); self.blocks.push(proto::Block { kind: Some(proto::block::Kind::Paragraph(proto::BlockText { offset, @@ -67,6 +69,8 @@ impl Doc { /// Adds a footer line after the existing content, such as a decided /// card's outcome. pub(crate) fn append_footer(&mut self, text: &str) { + let text = sanitize_visible_text(text); + let text = text.as_str(); if text.trim().is_empty() || self.markdown { return; } @@ -150,17 +154,9 @@ impl DocBuilder { /// [`finish`](Self::finish) drops the message's trailing newlines, and a /// range must never reach past the text. pub(crate) fn span(&mut self, text: &str) -> proto::BlockText { - let text = text.trim_end_matches(LINE_END); - let offset = self.utf16; - let length = text.encode_utf16().count() as i64; - self.text.push_str(text); - self.utf16 += length; - self.push_raw("\n"); - proto::BlockText { - offset, - length, - ..Default::default() - } + let span = self.inline_span(text); + self.newline(); + span } /// Appends text no block covers, such as a "Command: " label. @@ -172,6 +168,10 @@ impl DocBuilder { /// Appends text on the current line and returns its range, without a /// newline: a span followed by more text on the same line. pub(crate) fn inline_span(&mut self, text: &str) -> proto::BlockText { + // Sanitize before calculating offsets: removing bytes afterwards + // corrupts all subsequent UTF-16 ranges. NUL also truncates GRDB's + // native String decoding, making otherwise valid blocks disappear. + let text = sanitize_visible_text(text); let text = text.trim_end_matches(LINE_END); let offset = self.utf16; self.push_raw(text); @@ -217,6 +217,7 @@ impl DocBuilder { } pub(crate) fn paragraph(&mut self, text: &str) { + let text = sanitize_visible_text(text); if text.trim().is_empty() { return; } @@ -230,6 +231,7 @@ impl DocBuilder { } pub(crate) fn code(&mut self, text: &str, language: Option<&str>) { + let text = sanitize_visible_text(text); if text.is_empty() { return; } @@ -247,16 +249,8 @@ impl DocBuilder { if value.trim().is_empty() { continue; } - let label_span = { - let offset = self.utf16; - let text = format!("{label}: "); - self.push_raw(&text); - proto::BlockText { - offset, - length: label.encode_utf16().count() as i64, - ..Default::default() - } - }; + let label_span = self.inline_span(label); + self.push_raw(": "); let value_span = self.span(value.trim_end()); blocks.push(proto::BlockField { label: Some(label_span), @@ -458,22 +452,13 @@ impl DocBuilder { status: Status, build: impl FnOnce(&mut DocBuilder), ) { - let summary = summary.trim_end_matches(LINE_END); - let summary_offset = self.utf16; - let summary_len = summary.encode_utf16().count() as i64; - self.push_raw(summary); + let summary = self.inline_span(summary); let meta = meta .map(|meta| meta.trim_end_matches(LINE_END)) .filter(|meta| !meta.is_empty()) .map(|meta| { self.push_raw(" ยท "); - let offset = self.utf16; - self.push_raw(meta); - proto::BlockText { - offset, - length: meta.encode_utf16().count() as i64, - ..Default::default() - } + self.inline_span(meta) }); self.push_raw("\n"); let mut children = DocBuilder { @@ -485,11 +470,7 @@ impl DocBuilder { self.text = children.text; self.utf16 = children.utf16; self.push_block(proto::block::Kind::Disclosure(proto::BlockDisclosure { - summary: Some(proto::BlockText { - offset: summary_offset, - length: summary_len, - ..Default::default() - }), + summary: Some(summary), children: children.blocks, activity_kind: activity as i32, status: status.proto(), @@ -509,20 +490,11 @@ impl DocBuilder { elapsed: Option>, build: impl FnOnce(&mut DocBuilder), ) { - let summary = summary.trim_end_matches(LINE_END); - let summary_offset = self.utf16; - let summary_len = summary.encode_utf16().count() as i64; - self.push_raw(summary); + let summary = self.inline_span(summary); let elapsed = elapsed.filter(|_| working); let meta = elapsed.as_ref().map(|elapsed| { self.push_raw(" ยท "); - let offset = self.utf16; - self.push_raw(elapsed.text); - proto::BlockText { - offset, - length: elapsed.text.encode_utf16().count() as i64, - ..Default::default() - } + self.inline_span(elapsed.text) }); self.push_raw("\n"); let mut children = DocBuilder { @@ -539,11 +511,7 @@ impl DocBuilder { proto::block_disclosure::Kind::Default }; self.push_block(proto::block::Kind::Disclosure(proto::BlockDisclosure { - summary: Some(proto::BlockText { - offset: summary_offset, - length: summary_len, - ..Default::default() - }), + summary: Some(summary), kind: kind as i32, initially_open: Some(working), children: children.blocks, @@ -687,4 +655,67 @@ mod tests { }; assert_eq!((diff.additions, diff.deletions), (Some(1), Some(1))); } + + #[test] + fn binary_tool_output_is_sanitized_before_block_ranges_are_written() { + let mut builder = DocBuilder::new(); + builder.progress("Work\0ing", true, None, |progress| { + progress.disclosure( + "Ran\0 command ๐Ÿš€", + Some("1\u{1b}[31ms\u{1b}[0m"), + ActivityKind::Command, + Status::Done, + |row| row.code("before\0\u{12}\u{1b}[31mafter ๐Ÿš€\u{1b}[0m\r\n\tend", None), + ); + }); + let doc = builder.finish(); + assert_eq!( + doc.text, + "Working\nRan command ๐Ÿš€ ยท 1s\nbeforeafter ๐Ÿš€\n\tend" + ); + let Some(proto::block::Kind::Disclosure(progress)) = &doc.blocks[0].kind else { + panic!() + }; + assert_eq!(slice(&doc, progress.summary.as_ref().unwrap()), "Working"); + let Some(proto::block::Kind::Disclosure(row)) = &progress.children[0].kind else { + panic!() + }; + assert_eq!(slice(&doc, row.summary.as_ref().unwrap()), "Ran command ๐Ÿš€"); + assert_eq!(slice(&doc, row.meta.as_ref().unwrap()), "1s"); + let Some(proto::block::Kind::Code(code)) = &row.children[0].kind else { + panic!() + }; + assert_eq!( + slice(&doc, code.text.as_ref().unwrap()), + "beforeafter ๐Ÿš€\n\tend" + ); + } + + #[test] + fn control_only_text_adds_no_block() { + let mut builder = DocBuilder::new(); + builder.paragraph("\0\u{12}"); + builder.code("\0\u{1b}[31m", None); + assert!(builder.blocks.is_empty()); + assert!(builder.finish().text.is_empty()); + } + + #[test] + fn field_ranges_end_before_trailing_newlines_and_labels_are_sanitized() { + let mut builder = DocBuilder::new(); + builder.fields(&[("Rea\0son", "done ๐Ÿš€\n\n".to_owned(), false)]); + let doc = builder.finish(); + let Some(proto::block::Kind::Fields(fields)) = &doc.blocks[0].kind else { + panic!() + }; + assert_eq!( + slice(&doc, fields.fields[0].label.as_ref().unwrap()), + "Reason" + ); + assert_eq!( + slice(&doc, fields.fields[0].value.as_ref().unwrap()), + "done ๐Ÿš€" + ); + assert!(!Doc::markdown("before\0after").text.contains('\0')); + } } diff --git a/cli/src/bridge/v2/faults.rs b/cli/src/bridge/v2/faults.rs index e6e350343..26ff5ca84 100644 --- a/cli/src/bridge/v2/faults.rs +++ b/cli/src/bridge/v2/faults.rs @@ -313,6 +313,166 @@ fn spawn_work(runtime: &Runtime, cleanup: &mut Cleanup) -> crate::bridge::v2::wo handle.tx } +#[tokio::test] +async fn first_delivery_of_an_edited_agent_handoff_runs_once() { + let (mut runtime, harness, mut cleanup) = fixture(false); + runtime + .agent + .names + .remember(1, "Allowed agent".into()) + .await; + runtime.loop_roots.insert(9, 9); + let mut message = MessageRecord { + chat_id: InlineId::new(9), + message_id: InlineId::new(35), + sender_id: InlineId::new(1), + timestamp: 1, + is_outgoing: false, + reply_to_message_id: None, + transaction: None, + content: inline_client::MessageContent::Text { + text: "@Fault handle this".into(), + }, + metadata: inline_client::MessageMetadata { + sender_is_bot: Some(true), + revision: Some(4), + entities: vec![inline_client::MessageEntityRecord { + kind: "TYPE_MENTION".into(), + offset: 0, + length: 6, + user_id: Some(InlineId::new(2)), + agent_id: None, + group_id: None, + chat_id: None, + value: None, + }], + ..Default::default() + }, + }; + runtime.on_message(&message).await.unwrap(); + until(|| harness.session.sends.load(Ordering::SeqCst) == 1).await; + message.metadata.revision = Some(5); + runtime.on_message(&message).await.unwrap(); + assert_eq!(harness.session.sends.load(Ordering::SeqCst), 1); + cleanup.tasks.push(runtime.works.remove(&9).unwrap().task); +} + +#[tokio::test] +async fn an_observed_agent_reply_edited_into_a_handoff_runs_once() { + let (mut runtime, harness, mut cleanup) = fixture(false); + runtime + .agent + .names + .remember(1, "Allowed agent".into()) + .await; + runtime.loop_roots.insert(9, 9); + let mut message = MessageRecord { + chat_id: InlineId::new(9), + message_id: InlineId::new(36), + sender_id: InlineId::new(1), + timestamp: 1, + is_outgoing: false, + reply_to_message_id: None, + transaction: None, + content: inline_client::MessageContent::Text { + text: "Thinking".into(), + }, + metadata: inline_client::MessageMetadata { + sender_is_bot: Some(true), + ..Default::default() + }, + }; + // A streamed reply starts unaddressed and is only observed. + runtime.on_message(&message).await.unwrap(); + assert_eq!(harness.session.sends.load(Ordering::SeqCst), 0); + // Its final edit hands off to this agent. + message.content = inline_client::MessageContent::Text { + text: "@Fault handle this".into(), + }; + message.metadata.revision = Some(1); + message.metadata.entities = vec![inline_client::MessageEntityRecord { + kind: "TYPE_MENTION".into(), + offset: 0, + length: 6, + user_id: Some(InlineId::new(2)), + agent_id: None, + group_id: None, + chat_id: None, + value: None, + }]; + runtime.on_message(&message).await.unwrap(); + until(|| harness.session.sends.load(Ordering::SeqCst) == 1).await; + message.metadata.revision = Some(2); + runtime.on_message(&message).await.unwrap(); + assert_eq!(harness.session.sends.load(Ordering::SeqCst), 1); + cleanup.tasks.push(runtime.works.remove(&9).unwrap().task); +} + +#[tokio::test] +async fn replayed_agent_progress_does_not_invoke_or_exhaust_the_loop_guard() { + let (mut runtime, harness, _cleanup) = fixture(false); + runtime.agent.names.remember(3, "Other agent".into()).await; + runtime.loop_roots.insert(9, 9); + let mut message = MessageRecord { + chat_id: InlineId::new(9), + message_id: InlineId::new(35), + sender_id: InlineId::new(3), + timestamp: 1, + is_outgoing: false, + content: inline_client::MessageContent::Text { + text: "@Fault Working".into(), + }, + reply_to_message_id: None, + transaction: None, + metadata: inline_client::MessageMetadata { + sender_is_bot: Some(true), + ..Default::default() + }, + }; + for revision in 1..=100 { + message.metadata.revision = Some(revision); + tokio::time::timeout(Duration::from_millis(200), runtime.on_message(&message)) + .await + .expect("edits must not wait on the native session") + .unwrap(); + } + assert!(runtime.works.is_empty()); + assert!(harness.opened.lock().unwrap().is_empty()); + assert_eq!(harness.session.sends.load(Ordering::SeqCst), 0); + assert!(matches!( + runtime.loop_guards.record(9, true), + LoopVerdict::Allowed { .. } + )); +} + +#[tokio::test] +async fn agent_messages_not_addressed_to_this_agent_never_reach_the_loop_cap() { + let (mut runtime, harness, _cleanup) = fixture(false); + runtime.agent.names.remember(3, "Other agent".into()).await; + runtime.loop_roots.insert(9, 9); + for message_id in 1..=(i64::from(DEFAULT_LOOP_CAP_HOPS) + 5) { + let message = MessageRecord { + chat_id: InlineId::new(9), + message_id: InlineId::new(message_id), + sender_id: InlineId::new(3), + timestamp: 1, + is_outgoing: false, + content: inline_client::MessageContent::Text { + text: "Working".into(), + }, + reply_to_message_id: None, + transaction: None, + metadata: inline_client::MessageMetadata { + sender_is_bot: Some(true), + ..Default::default() + }, + }; + runtime.on_message(&message).await.unwrap(); + } + assert!(runtime.loop_guards.guard(9).is_none()); + assert_eq!(harness.session.sends.load(Ordering::SeqCst), 0); +} + #[tokio::test] async fn service_messages_are_skipped_but_identical_human_text_still_runs() { let (mut runtime, harness, mut cleanup) = fixture(false); @@ -1284,7 +1444,7 @@ async fn a_thread_v1_served_goes_on_in_its_session_and_folder() { let _ = task.await; drop(runtime); // The next process sees the registered session on Inline. Its folder - // survives in the v2 ledger without the legacy store attached. + // must survive in the v2 ledger, even without the legacy store attached. let mut restarted = super::faults::runtime(&mut cleanup, harness.clone()); restarted.ensure_work(9, None).await.unwrap(); let (id, command) = input(&restarted, 95); @@ -1294,6 +1454,33 @@ async fn a_thread_v1_served_goes_on_in_its_session_and_folder() { cleanup.tasks.push(restarted.works.remove(&9).unwrap().task); } +#[tokio::test] +async fn an_already_registered_legacy_session_keeps_its_folder_without_overriding_new_choices() { + for (legacy_session, explicit_folder, use_legacy) in [ + ("fault-session", false, true), + ("fault-session", true, false), + ("another-session", false, false), + ] { + let (mut runtime, harness, mut cleanup, other) = v1_fixture(legacy_session); + Arc::get_mut(&mut runtime.agent).unwrap().owner = Arc::new(Owner); + if explicit_folder { + runtime.thread_settings.entry(9).or_default().folder = + Some(runtime.config.folder.clone()); + } + runtime.ensure_work(9, None).await.unwrap(); + let (id, command) = input(&runtime, 96); + runtime.works[&9].tx.send(command).await.unwrap(); + until(|| state(&runtime, &id) == Some(InputState::Accepted)).await; + let expected = if use_legacy { + &other + } else { + &runtime.config.folder + }; + assert_eq!(&harness.opened.lock().unwrap()[0].folder, expected); + cleanup.tasks.push(runtime.works.remove(&9).unwrap().task); + } +} + #[tokio::test] async fn registered_acp_legacy_sessions_inherit_only_their_matching_folder() { for vocabulary in [Vocabulary::OpenCode, Vocabulary::Amp] { diff --git a/cli/src/bridge/v2/intake.rs b/cli/src/bridge/v2/intake.rs index d47521ad5..d0a37fa6e 100644 --- a/cli/src/bridge/v2/intake.rs +++ b/cli/src/bridge/v2/intake.rs @@ -32,6 +32,15 @@ pub(crate) fn message_text(content: &MessageContent) -> &str { } } +pub(crate) fn is_agent_edit(message: &MessageRecord) -> bool { + message.metadata.sender_is_bot == Some(true) + && (message + .metadata + .revision + .is_some_and(|revision| revision > 0) + || message.metadata.edit_timestamp.is_some()) +} + pub(crate) fn group_message(message: &MessageRecord, facts: MessageFacts<'_>) -> GroupMessage { let text = message_text(&message.content).to_owned(); let units = text.encode_utf16().collect::>(); @@ -57,6 +66,12 @@ pub(crate) fn group_message(message: &MessageRecord, facts: MessageFacts<'_>) -> }), "TYPE_BOT_COMMAND" => { let start = offset as usize; + // A pasted transcript can carry command entities far + // inside its tool output. Only a command at the start, + // optionally after structured mentions, is an action. + if !has_command_prefix(message, &units, start) { + return None; + } let end = start.checked_add(length as usize)?.min(units.len()); let raw = String::from_utf16_lossy(units.get(start..end)?); let (name, text_target) = @@ -115,6 +130,44 @@ pub(crate) fn group_message(message: &MessageRecord, facts: MessageFacts<'_>) -> } } +fn has_command_prefix(message: &MessageRecord, units: &[u16], start: usize) -> bool { + let Some(prefix) = units.get(..start) else { + return false; + }; + let mut prefix = prefix.to_vec(); + let mut mentioned = false; + for entity in &message.metadata.entities { + if matches!(entity.kind.as_str(), "TYPE_CODE" | "TYPE_PRE") + && entity.offset >= 0 + && entity.length > 0 + && entity.offset as u64 <= start as u64 + && (start as u64) < (entity.offset as u64).saturating_add(entity.length as u64) + { + return false; + } + if !matches!(entity.kind.as_str(), "TYPE_MENTION" | "TYPE_GROUP_MENTION") { + continue; + } + let (Ok(offset), Ok(length)) = ( + usize::try_from(entity.offset), + usize::try_from(entity.length), + ) else { + continue; + }; + if let Some(end) = offset.checked_add(length) + && let Some(mention) = prefix.get_mut(offset..end) + { + mention.fill(u16::from(b' ')); + mentioned = true; + } + } + String::from_utf16(&prefix).is_ok_and(|prefix| { + prefix.chars().all(|character| { + character.is_whitespace() || (mentioned && matches!(character, ',' | ':' | ';' | '&')) + }) + }) +} + /// How long a request stays open for its answer to come back as a hand-back. pub(crate) const HAND_BACK_WINDOW_SECS: i64 = 7 * 24 * 3600; @@ -329,6 +382,104 @@ mod tests { assert_eq!(classify_addressee(&theirs, BOT), AddresseeKind::Others); } + #[test] + fn pasted_command_examples_are_content() { + for text in [ + "Working\n2588: * command: /model , the /config Model row", + "Please explain /stop without stopping this run", + "```\n/model opus\n```", + ] { + let start = text.find('/').unwrap(); + let command = text[start..].split_whitespace().next().unwrap(); + let message = group_message( + &record( + text, + vec![entity( + "TYPE_BOT_COMMAND", + start as i64, + command.len() as i64, + None, + )], + ), + facts(), + ); + assert_eq!(message.command(), None, "{text}"); + } + } + + #[test] + fn commands_after_leading_mentions_still_work_with_utf16_offsets() { + let text = " @๐Ÿค– /model opus"; + let offset = text[..text.find('/').unwrap()].encode_utf16().count() as i64; + let message = group_message( + &record( + text, + vec![ + entity("TYPE_MENTION", 2, 3, Some(BOT)), + entity("TYPE_BOT_COMMAND", offset, 6, None), + ], + ), + facts(), + ); + assert_eq!(message.command(), Some(("model", None))); + } + + #[test] + fn a_literal_command_in_a_code_block_is_not_an_action() { + for kind in ["TYPE_CODE", "TYPE_PRE"] { + let message = group_message( + &record( + "/stop", + vec![ + entity("TYPE_BOT_COMMAND", 0, 5, None), + entity(kind, 0, 5, None), + ], + ), + facts(), + ); + assert_eq!(message.command(), None); + } + } + + #[test] + fn leading_mention_separators_keep_commands_actionable() { + for prefix in ["@Codex: ", "@Codex; ", "@Alice, @Codex & "] { + let text = format!("{prefix}/stop"); + let mentions: Vec<_> = ["@Alice", "@Codex"] + .into_iter() + .filter_map(|name| { + prefix.find(name).map(|offset| { + entity("TYPE_MENTION", offset as i64, name.len() as i64, Some(BOT)) + }) + }) + .chain(std::iter::once(entity( + "TYPE_BOT_COMMAND", + prefix.len() as i64, + 5, + None, + ))) + .collect(); + assert_eq!( + group_message(&record(&text, mentions), facts()).command(), + Some(("stop", None)) + ); + } + } + + #[test] + fn streamed_agent_edits_are_distinct_from_new_input_and_human_edits() { + let mut message = record("Working", vec![]); + message.metadata.sender_is_bot = Some(true); + assert!(!is_agent_edit(&message)); + message.metadata.revision = Some(90); + assert!(is_agent_edit(&message)); + message.metadata.revision = Some(0); + message.metadata.edit_timestamp = Some(1); + assert!(is_agent_edit(&message)); + message.metadata.sender_is_bot = Some(false); + assert!(!is_agent_edit(&message)); + } + #[test] fn bot_authors_carry_their_owner_and_replies_their_hand_back_fact() { let mut bot_record = record("The tests pass.", Vec::new()); diff --git a/cli/src/bridge/v2/render.rs b/cli/src/bridge/v2/render.rs index d222fc7e8..103401988 100644 --- a/cli/src/bridge/v2/render.rs +++ b/cli/src/bridge/v2/render.rs @@ -461,20 +461,68 @@ impl Renderer { /// Creates or edits the open progress message. Near a server limit the /// message ends and the rest continues in a new one. fn push_progress(&mut self, ops: &mut Vec) { - let Some(id) = self.slot.as_ref().map(|slot| slot.id) else { - return; - }; - let doc = self.progress_doc(); - if limits::progress_fits(&doc) || !self.split_slot(ops) { + loop { + let Some(slot) = self.slot.as_ref() else { + return; + }; + let id = slot.id; + let doc = self.progress_doc(); + if !limits::progress_fits(&doc) && self.split_slot(ops) { + continue; + } + let doc = self.bounded_progress(self.slot.as_ref().unwrap(), "Working", true, doc); ops.push(RenderOp::Progress { slot: id, doc }); return; } - if let Some(slot) = &self.slot { - ops.push(RenderOp::Progress { - slot: slot.id, - doc: self.progress_doc(), + } + + /// A running child or a single large command cannot move to a finished + /// message yet. Keep its recent activity visible within the same native + /// progress disclosure instead of repeatedly publishing an invalid edit. + fn bounded_progress(&self, slot: &Slot, summary: &str, working: bool, doc: Doc) -> Doc { + if limits::progress_fits(&doc) { + return doc; + } + // The bounded view keeps the live elapsed time a working row shows. + let (started_at, elapsed_text) = self.progress_elapsed(slot); + let elapsed = || { + Some(Elapsed { + started_at, + text: &elapsed_text, + }) + }; + let mut keep = slot.rows.len() / 2; + while keep > 0 { + let recent = recent_rows(slot, keep); + let mut builder = DocBuilder::new(); + builder.progress(summary, working, elapsed(), |inner| { + inner.paragraph( + "Showing recent activity; earlier details remain in the agent session.", + ); + self.write_slot(inner, &recent); }); + let limited = builder.finish(); + if limits::progress_fits(&limited) { + return limited; + } + keep /= 2; } + // Even one command's arguments can exceed the entire message limit. + let tail: String = doc + .text + .chars() + .rev() + .take(30_000) + .collect::>() + .into_iter() + .rev() + .collect(); + let mut builder = DocBuilder::new(); + builder.progress(summary, working, elapsed(), |inner| { + inner.paragraph("Showing recent output; full details remain in the agent session."); + inner.code(&tail, None); + }); + builder.finish() } /// Ends the open message with the longest run of finished rows that fits, @@ -709,6 +757,7 @@ impl Renderer { } else { self.ended_doc(&slot, &summary, plan) }; + let doc = self.bounded_progress(&slot, &summary, false, doc); ops.push(RenderOp::EndProgress { slot: id, doc }); } @@ -813,12 +862,7 @@ impl Renderer { fn progress_doc(&self) -> Doc { let mut builder = DocBuilder::new(); - let elapsed = self.slot.as_ref().map(|slot| { - ( - (slot.started_ms / 1000) as i64, - elapsed_text(self.now_ms.saturating_sub(slot.started_ms)), - ) - }); + let elapsed = self.slot.as_ref().map(|slot| self.progress_elapsed(slot)); let elapsed = elapsed.as_ref().map(|(started_at, text)| Elapsed { started_at: *started_at, text, @@ -832,6 +876,14 @@ impl Renderer { builder.finish() } + /// A slot's start, Unix seconds, and its time so far. + fn progress_elapsed(&self, slot: &Slot) -> (i64, String) { + ( + (slot.started_ms / 1000) as i64, + elapsed_text(self.now_ms.saturating_sub(slot.started_ms)), + ) + } + fn write_rows(&self, builder: &mut DocBuilder) { if let Some(slot) = &self.slot { self.write_slot(builder, slot); @@ -1567,6 +1619,34 @@ fn subset(slot: &Slot, tops: &[usize]) -> Slot { } } +/// Recent rows plus the sub-agent ancestors needed to display them. +fn recent_rows(slot: &Slot, count: usize) -> Slot { + let mut keep = std::collections::HashSet::new(); + let mut pending: Vec<&Row> = slot.rows.iter().rev().take(count).collect(); + while let Some(row) = pending.pop() { + if !keep.insert(row.id.as_str()) { + continue; + } + if let Some(parent) = &row.parent + && let Some(ancestor) = slot.rows.iter().find(|candidate| { + matches!(&candidate.body, Some(ItemBody::Child { child, .. }) if child.id.as_str() == parent) + }) + { + pending.push(ancestor); + } + } + Slot { + id: slot.id, + started_ms: slot.started_ms, + rows: slot + .rows + .iter() + .filter(|row| keep.contains(row.id.as_str())) + .cloned() + .collect(), + } +} + fn update(text: &str) -> RenderOp { RenderOp::Update { doc: Doc::markdown(text), @@ -2367,6 +2447,66 @@ mod tests { ); } + #[test] + fn unfinished_activity_and_one_large_command_stay_within_message_limits() { + for huge_command in [false, true] { + let mut renderer = Renderer::new(OutputMode::Detailed, Vocabulary::Claude, "Claude"); + let mut events = vec![(0, turn(TurnPhase::Started { inputs: vec![] }))]; + let count = if huge_command { 1 } else { 70 }; + for index in 0..count { + let command = if huge_command { + "๐Ÿš€".repeat(110_000) + } else { + format!("command-{index}") + }; + events.push(( + index + 1, + Event::Item(Item::new( + ItemId::new(format!("live-{index}")).unwrap(), + None, + ItemUpdate::Started { + body: ItemBody::Command { + command, + cwd: None, + actions: vec![], + exit_code: None, + duration_ms: None, + output: Some("x".repeat(2_000)), + }, + }, + Value::Null, + )), + )); + } + events.push(( + 100, + turn(TurnPhase::Completed { + outcome: TurnOutcome::Completed, + inputs_consumed: vec![], + error: None, + duration_ms: Some(100), + }), + )); + let ops = run(&mut renderer, events); + let mut bounded = false; + for op in ops { + if let RenderOp::Progress { doc, .. } | RenderOp::EndProgress { doc, .. } = op { + assert!( + limits::Size::of(&doc).fits(), + "{:?}", + limits::Size::of(&doc) + ); + assert!(matches!( + doc.blocks[0].kind, + Some(inline_protocol::proto::block::Kind::Disclosure(_)) + )); + bounded |= doc.text.contains("Showing recent"); + } + } + assert!(bounded, "large live activity needs a bounded view"); + } + } + #[test] fn long_output_shows_its_end_with_the_hidden_line_count() { let text = (0..1000) diff --git a/cli/src/bridge/v2/runtime.rs b/cli/src/bridge/v2/runtime.rs index ae812face..8d7e0c1d2 100644 --- a/cli/src/bridge/v2/runtime.rs +++ b/cli/src/bridge/v2/runtime.rs @@ -5,7 +5,7 @@ //! records direct input in the ledger before acknowledging the delivery, and //! hands it to the thread's work actor (`work.rs`). -use std::collections::{HashMap, HashSet}; +use std::collections::{HashMap, HashSet, VecDeque}; use std::path::{Path, PathBuf}; use std::sync::Arc; use std::time::{Duration, Instant}; @@ -13,11 +13,11 @@ use std::time::{Duration, Instant}; use inline_agent_bridge::HostToolResult; use inline_agent_bridge::ProviderSessionId; use inline_agent_bridge::group::{ - ContextAuthorRole, ContextMessage, Conversation, DEFAULT_DAILY_SPEAK_GATE_BUDGET, - DEFAULT_LOOP_CAP_HOPS, DailySpeakGateBudget, DayKey, DirectReason, Grants, GroupMessage, - IntakeDecision, IntakeFacts, LoopGuards, LoopVerdict, ObserveReason, Operation, - ParticipationMode, PendingInput, ReleaseCause, WorkPhase, decide_intake, direct_input, - envelope_of, origin_of, required_operation, + AddresseeKind, ContextAuthorRole, ContextMessage, Conversation, + DEFAULT_DAILY_SPEAK_GATE_BUDGET, DEFAULT_LOOP_CAP_HOPS, DailySpeakGateBudget, DayKey, + DirectReason, Grants, GroupMessage, IntakeDecision, IntakeFacts, LoopGuards, LoopVerdict, + ObserveReason, Operation, ParticipationMode, PendingInput, ReleaseCause, WorkPhase, + classify_addressee, decide_intake, direct_input, envelope_of, origin_of, required_operation, }; use inline_agent_bridge::harness::{ Catalog, CatalogScope, Delivery, HarnessDriver, Input, InputContent, InputId, OpKind, @@ -338,6 +338,8 @@ pub(crate) struct Runtime { /// Skills by thread folder, briefly: Amp takes seconds to list them. listed_skills: HashMap)>, agent_profiles: Option<(BotAgentResolver, SqliteStore)>, + seen_agent_messages: HashSet<(i64, i64)>, + agent_message_order: VecDeque<(i64, i64)>, /// Tests: sent messages as Inline holds them, read instead of asking. #[cfg(test)] cards: HashMap<(i64, i64), super::doc::Doc>, @@ -439,6 +441,8 @@ impl Runtime { skills: None, listed_skills: HashMap::new(), agent_profiles: None, + seen_agent_messages: HashSet::new(), + agent_message_order: VecDeque::new(), #[cfg(test)] cards: HashMap::new(), }) @@ -2368,6 +2372,48 @@ impl Runtime { } else { message }; + // Streamed progress is one agent message, not a new bot-to-bot + // invocation on every edit. Keep its latest context without counting + // another loop hop or replaying a command/mention. + let agent_message = (message.chat_id.get(), message.message_id.get()); + let already_handled = || -> Result> { + if self.seen_agent_messages.contains(&agent_message) { + return Ok(true); + } + for kind in ["direct", "command"] { + if self + .agent + .ledger + .get(&input_id( + self.config.bot_user_id, + agent_message.0, + agent_message.1, + kind, + ))? + .is_some() + { + return Ok(true); + } + } + Ok(false) + }; + if super::intake::is_agent_edit(message) && already_handled()? { + if let Some(work) = self.works.get(&message.chat_id.get()) { + let _ = work + .tx + .send(Command::Passive { + message: ContextMessage { + message_id: message.message_id.get(), + author_name: self.agent.names.of(message.sender_id.get()).await, + role: ContextAuthorRole::Agent, + reply_to: message.reply_to_message_id.map(InlineId::get), + text: super::intake::message_text(&message.content).to_owned(), + }, + }) + .await; + } + return Ok(None); + } let chat_id = message.chat_id.get(); // The agent's own threads are the ones it made (`/new`, a moved work's // subthread, `create_chat`) or that are bound to it. A shared thread it @@ -2439,7 +2485,17 @@ impl Runtime { .get(&chat_id) .map_or(WorkPhase::None, |work| *work.phase.borrow()); let scope = self.loop_scope(chat_id).await; - let loop_verdict = self.loop_guards.record(scope, group.author.kind.is_agent()); + // Only agent messages addressed to this agent can start a loop with it; + // others talking in the thread never count toward its cap. + let loop_verdict = if group.author.kind.is_agent() + && !matches!( + classify_addressee(&group, self.config.bot_user_id), + AddresseeKind::Me { .. } + ) { + LoopVerdict::Allowed { hops: 0 } + } else { + self.loop_guards.record(scope, group.author.kind.is_agent()) + }; if let LoopVerdict::CapReached { limit, notify_owners: true, @@ -2498,7 +2554,10 @@ impl Runtime { { self.access_notice(chat_id, &group).await; } - match decision { + // Only an acted-on agent message counts as handled: a streamed reply + // that was observed can still be edited into a handoff later. + let acted = matches!(decision, IntakeDecision::Act { .. }); + let result = match decision { IntakeDecision::Act { join, required, .. } => { if join && conversation == Conversation::Group @@ -2556,7 +2615,20 @@ impl Runtime { Ok(Some(decision)) } IntakeDecision::Skip { .. } => Ok(Some(decision)), + }; + if result.is_ok() + && acted + && group.author.kind.is_agent() + && self.seen_agent_messages.insert(agent_message) + { + self.agent_message_order.push_back(agent_message); + if self.agent_message_order.len() > 4096 + && let Some(oldest) = self.agent_message_order.pop_front() + { + self.seen_agent_messages.remove(&oldest); + } } + result } /// Who wrote the replied-to message (0 when unknown), and whether it diff --git a/cli/src/bridge/v2/work.rs b/cli/src/bridge/v2/work.rs index c48bb28b5..21fc6e176 100644 --- a/cli/src/bridge/v2/work.rs +++ b/cli/src/bridge/v2/work.rs @@ -497,6 +497,7 @@ pub(crate) fn spawn( offers: HashMap::new(), slots: HashMap::new(), edits: HashMap::new(), + resend: HashSet::new(), reported: None, working_due: None, phase: phase_tx, @@ -640,6 +641,10 @@ struct Actor { offers: HashMap, slots: HashMap, edits: HashMap, + /// Slots whose message refused an edit. Their next progress goes out as a + /// new message on the edit cadence, so a refusal that also hits sends + /// cannot turn every event into a request. + resend: HashSet, /// The state last published, without its revision and time, so any /// published change (queue count, attention) is sent again. reported: Option, @@ -3162,8 +3167,8 @@ impl Actor { for op in ops { log::debug!(target: "inline::bridge::v2", "chat={} render={}", self.chat_id, render_kind(&op)); match op { - RenderOp::Progress { slot, doc } => match self.slots.get(&slot) { - Some(_) => { + RenderOp::Progress { slot, doc } => { + if self.slots.contains_key(&slot) || self.resend.contains(&slot) { let due = tokio::time::Instant::now() + EDIT_INTERVAL; self.edits .entry(slot) @@ -3174,15 +3179,13 @@ impl Actor { actions: None, closing: false, }); + } else if let Some(id) = self.send(&doc, None, Notify::Silent).await { + self.slots.insert(slot, id); } - None => { - if let Some(id) = self.send(&doc, None, Notify::Silent).await { - self.slots.insert(slot, id); - } - } - }, + } RenderOp::EndProgress { slot, doc } => { self.edits.remove(&slot); + self.resend.remove(&slot); match self.slots.get(&slot).copied() { Some(message_id) => { match self.try_edit(self.chat_id, message_id, &doc, None).await { @@ -3199,7 +3202,11 @@ impl Actor { }, ); } - _ => { + Err(Failure::Refused | Failure::Gone) => { + self.slots.remove(&slot); + self.send(&doc, None, Notify::Silent).await; + } + Ok(()) => { self.slots.remove(&slot); } } @@ -3362,9 +3369,16 @@ impl Actor { .map(|(slot, _)| *slot) .collect(); for slot in due { - let (Some(edit), Some(message_id)) = - (self.edits.remove(&slot), self.slots.get(&slot).copied()) - else { + let Some(edit) = self.edits.remove(&slot) else { + continue; + }; + let Some(message_id) = self.slots.get(&slot).copied() else { + if self.resend.contains(&slot) + && let Some(id) = self.send(&edit.doc, None, Notify::Silent).await + { + self.resend.remove(&slot); + self.slots.insert(slot, id); + } continue; }; match self @@ -3383,12 +3397,15 @@ impl Actor { ..edit }); } - // Never retried as it is: the renderer keeps messages within - // Inline's limits, so this is rare and reported. The next - // edit of an open message may still land. + // This message can no longer be edited (for example after + // deletion or becoming a subthread parent). The next update + // starts a fresh progress message instead of freezing here. Err(Failure::Refused | Failure::Gone) => { + self.slots.remove(&slot); if edit.closing { - self.slots.remove(&slot); + self.send(&edit.doc, None, Notify::Silent).await; + } else { + self.resend.insert(slot); } } } @@ -3508,7 +3525,7 @@ impl Actor { Err(error) => { let failure = error.failure(); if failure == Failure::Refused { - log::error!(target: "inline::bridge::v2", "chat={chat_id} edit refused: {error} ({:?})", limits::Size::of(doc)); + log::error!(target: "inline::bridge::v2", "chat={chat_id} message={message_id} edit refused: {error} ({:?})", limits::Size::of(doc)); crate::telemetry::report_bridge_output_refused("edit"); } else { log::warn!(target: "inline::bridge::v2", "edit failed: {error}"); @@ -4605,6 +4622,7 @@ pub(crate) mod recovery_tests { offers: HashMap::new(), slots: HashMap::new(), edits: HashMap::new(), + resend: HashSet::new(), reported: None, working_due: None, phase: phase_tx, diff --git a/crates/agent-bridge/src/group/caps.rs b/crates/agent-bridge/src/group/caps.rs index 8d8eafc3f..c55a8a6b8 100644 --- a/crates/agent-bridge/src/group/caps.rs +++ b/crates/agent-bridge/src/group/caps.rs @@ -139,10 +139,10 @@ pub enum LoopVerdict { }, } -/// Agent-only hop counter for one conversation. Every message the agent -/// receives there is recorded: another agent's adds a hop and a person's -/// resets the count. Its own messages are not counted, so the cap counts -/// the other side's turns. +/// Agent-only hop counter for one conversation. Another agent's message +/// addressed to this agent adds a hop and any person's message resets the +/// count. Its own messages are not counted, so the cap counts the other +/// side's turns. #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] pub struct LoopGuard { hops: u32, diff --git a/crates/agent-bridge/src/group/context.rs b/crates/agent-bridge/src/group/context.rs index efcf6134c..1976b8e57 100644 --- a/crates/agent-bridge/src/group/context.rs +++ b/crates/agent-bridge/src/group/context.rs @@ -281,11 +281,12 @@ impl PassiveBatch { } pub fn push(&mut self, message: ContextMessage) { - if self + if let Some(queued) = self .messages - .iter() - .any(|queued| queued.message_id == message.message_id) + .iter_mut() + .find(|queued| queued.message_id == message.message_id) { + *queued = message; return; } if self.messages.len() == MAX_PASSIVE_BUFFER { @@ -695,4 +696,25 @@ mod tests { ); assert!(drained.included_message_ids[0] >= 5); } + + #[test] + fn streamed_edits_replace_context_without_counting_as_more_messages() { + let mut batch = PassiveBatch::new(3); + batch.push(message(1, ContextAuthorRole::Agent, "Working")); + batch.push(message(2, ContextAuthorRole::Owner, "Follow-up")); + for revision in 1..=100 { + batch.push(message( + 1, + ContextAuthorRole::Agent, + &format!("Progress {revision}"), + )); + } + assert_eq!(batch.len(), 2); + let context = batch.drain(ContextBudget::bytes(MAX_BYTES)).unwrap(); + assert_eq!(context.included_message_ids, [1, 2]); + assert_eq!(context.omitted, 0); + assert!(context.text.contains("Progress 100")); + assert!(!context.text.contains("Working")); + assert!(context.text.find("Progress 100") < context.text.find("Follow-up")); + } } diff --git a/crates/agent-bridge/src/lib.rs b/crates/agent-bridge/src/lib.rs index 6e0f2a0aa..ebdd98267 100644 --- a/crates/agent-bridge/src/lib.rs +++ b/crates/agent-bridge/src/lib.rs @@ -46,8 +46,8 @@ pub use presentation::{ ActivityKind, NativeToolActivity, PresentationUpdate, SemanticActivity, StreamingPresenter, UpdatePriority, ValidationSummary, VisibilityMode, VisibilityPolicy, WORKING_CONTINUED_STATUS, WORKING_STATUS, format_elapsed_compact, native_tool_activity, render_completion_summary, - sanitize_diagnostic_text, sanitize_visible_command, sanitize_visible_transcript, - semantic_activity_title, + sanitize_diagnostic_text, sanitize_visible_command, sanitize_visible_text, + sanitize_visible_transcript, semantic_activity_title, }; pub use process_host::{ ProcessHostConfig, ProcessHostError, reap_stale_process_host, run_process_host, diff --git a/crates/agent-bridge/src/presentation.rs b/crates/agent-bridge/src/presentation.rs index 6e9c4a105..b3ecc5d73 100644 --- a/crates/agent-bridge/src/presentation.rs +++ b/crates/agent-bridge/src/presentation.rs @@ -1078,7 +1078,9 @@ fn previous_char_boundary(value: &str, maximum: usize) -> usize { boundary } -fn sanitize_visible_text(value: &str) -> String { +/// Removes terminal escape sequences and non-whitespace control characters +/// before text is published to native clients or assigned rich-text ranges. +pub fn sanitize_visible_text(value: &str) -> String { let mut output = String::with_capacity(value.len()); let mut chars = value.chars().peekable(); while let Some(character) = chars.next() { diff --git a/crates/agent-bridge/src/store/session_picker.rs b/crates/agent-bridge/src/store/session_picker.rs index 43da5374b..89e8a39d5 100644 --- a/crates/agent-bridge/src/store/session_picker.rs +++ b/crates/agent-bridge/src/store/session_picker.rs @@ -718,6 +718,26 @@ impl BridgeStore { Ok(changed == 1) } + /// Retires controls owned by a runtime that will no longer handle them. + /// Completed picks keep their session links; unfinished picks use the + /// existing terminal-card recovery path, including after a failed edit. + pub fn expire_session_pickers_for_installation( + &self, + installation_id: &InstallationId, + now: i64, + ) -> StoreResult { + let connection = self.connection.lock().expect("bridge store poisoned"); + Ok(connection.execute( + "UPDATE session_pickers SET + state = CASE WHEN thread_chat_id IS NULL THEN 'expired' ELSE 'failed' END, + lease_owner = NULL, lease_expires_at = NULL, + terminal_projected = 0, updated_at = ?2 + WHERE installation_id = ?1 + AND state IN ('publishing', 'active', 'opening', 'retryable')", + params![installation_id.as_str(), now], + )?) + } + pub fn recover_session_pickers( &self, installation_id: &InstallationId, @@ -1905,6 +1925,103 @@ mod tests { assert_eq!(retained.agent_session_id, Some(30)); } + #[test] + fn runtime_switch_retires_only_unfinished_pickers_and_keeps_cleanup_retryable() { + for (state, thread, expected) in [ + ("publishing", None, SessionPickerState::Expired), + ("active", None, SessionPickerState::Expired), + ("opening", Some(21), SessionPickerState::Failed), + ("retryable", Some(21), SessionPickerState::Failed), + ("completed", Some(21), SessionPickerState::Completed), + ] { + let (store, picker, _workspace) = memory_fixture(); + store.insert_session_picker(&picker).unwrap(); + if state != "publishing" { + store + .attach_session_picker_message(&picker.callback_token, 13, 101) + .unwrap(); + } + // Seed the persisted checkpoints an interrupted process can leave. + store + .connection + .lock() + .unwrap() + .execute( + "UPDATE session_pickers SET state = ?1, thread_chat_id = ?2, + lease_owner = 'old-process', lease_expires_at = 150 WHERE callback_token = ?3", + params![state, thread, picker.callback_token], + ) + .unwrap(); + assert_eq!( + store + .expire_session_pickers_for_installation( + &InstallationId::new("another-installation").unwrap(), + 110 + ) + .unwrap(), + 0 + ); + let completed = state == "completed"; + assert_eq!( + store + .expire_session_pickers_for_installation(&picker.installation_id, 110) + .unwrap(), + usize::from(!completed) + ); + assert_eq!( + store + .expire_session_pickers_for_installation(&picker.installation_id, 111) + .unwrap(), + 0 + ); + store + .recover_session_pickers(&picker.installation_id, 112) + .unwrap(); + let current = store + .session_picker(&picker.callback_token) + .unwrap() + .unwrap(); + assert_eq!(current.state, expected); + assert_eq!(current.thread_chat_id, thread); + if !completed { + assert!(current.lease_owner.is_none()); + assert!(current.lease_expires_at.is_none()); + assert!( + store + .recoverable_session_picker_commands(&picker.installation_id) + .unwrap() + .is_empty() + ); + } + let cards = store + .session_picker_recovery_cards(&picker.installation_id) + .unwrap(); + assert_eq!( + cards.len(), + usize::from(!completed && state != "publishing") + ); + if !cards.is_empty() { + // A failed UI edit remains pending; only a successful edit clears it. + assert_eq!( + store + .session_picker_recovery_cards(&picker.installation_id) + .unwrap() + .len(), + 1 + ); + store + .mark_session_picker_terminal_projected(&picker.callback_token, 113) + .unwrap(); + assert!( + store + .session_picker_recovery_cards(&picker.installation_id) + .unwrap() + .is_empty() + ); + } + } + } + #[test] fn startup_recovery_reclaims_a_live_lease_once_old_tasks_are_gone() { let (store, picker, _workspace) = memory_fixture(); diff --git a/crates/agent-driver-codex/src/harness/connection.rs b/crates/agent-driver-codex/src/harness/connection.rs index b19b2dfff..901d27d6c 100644 --- a/crates/agent-driver-codex/src/harness/connection.rs +++ b/crates/agent-driver-codex/src/harness/connection.rs @@ -3,6 +3,7 @@ use std::collections::HashMap; use std::path::PathBuf; +use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::{Arc, Mutex as StdMutex, Weak}; use std::time::Duration; @@ -81,6 +82,26 @@ impl Connection { .request_with_timeout(request.method, request.params, REQUEST_TIMEOUT) .await } + + async fn opening_request(&self, request: Request) -> Result<(Value, u64), PeerError> { + tokio::time::timeout( + REQUEST_TIMEOUT, + self.peer + .request_with_wire_sequence(request.method, request.params), + ) + .await + .unwrap_or_else(|_| Err(PeerError::Timeout(request.method.to_owned()))) + } + + fn remove_session(&self, inner: &SessionInner) { + let mut sessions = self.sessions.lock().expect("session map poisoned"); + if sessions + .get(&inner.thread) + .is_some_and(|known| std::ptr::eq(known.as_ptr(), inner)) + { + sessions.remove(&inner.thread); + } + } } impl CodexHarness { @@ -112,6 +133,82 @@ impl CodexHarness { *self.host_tools.lock().expect("host tools poisoned") = Some(configuration); } + async fn open_once(&self, spec: &OpenSpec) -> Result, OpenError> { + let connection = self.connection().await?; + let Request { method, params } = super::delivery::open_request(spec, self.dynamic_tools()); + // A resume can run input persisted in the native queue and ask for + // approval right away, so the session listens before it loads, and + // the queue it may run is published first. + let early = match &spec.mode { + OpenMode::Resume { session } => { + let inner = SessionInner::new(&connection, session.as_str().to_owned())?; + connection + .sessions + .lock() + .expect("session map poisoned") + .insert(inner.thread.clone(), Arc::downgrade(&inner)); + let _ = inner.refresh_queue().await; + Some(inner) + } + _ => None, + }; + let (response, response_sequence) = + match connection.opening_request(Request { method, params }).await { + Ok(response) => response, + Err(error) => { + if let Some(inner) = &early { + connection.remove_session(inner); + } + return Err(open_error(error)); + } + }; + let thread = response + .pointer("/thread/id") + .and_then(Value::as_str) + .ok_or_else(|| { + OpenError::Driver(DriverError::Protocol(format!( + "{method} response has no thread id" + ))) + })? + .to_owned(); + let settings = EffectiveSettings { + model: text(response.get("model")).map(|model| DriverSettingOption { + value: model.clone(), + label: model, + description: None, + disabled: false, + }), + effort: text(response.get("reasoningEffort")), + speed: text(response.get("serviceTier")), + permission_mode: text(response.pointer("/activePermissionProfile/id")), + mode: None, + folder: text(response.get("cwd")).map(PathBuf::from), + }; + let inner = match early { + Some(inner) if inner.thread == thread => inner, + _ => { + let inner = SessionInner::new(&connection, thread.clone())?; + connection + .sessions + .lock() + .expect("session map poisoned") + .insert(thread, Arc::downgrade(&inner)); + inner + } + }; + *inner.model.lock().expect("model poisoned") = + settings.model.as_ref().map(|model| model.value.clone()); + inner.hub.emit(Event::Settings { + effective: settings, + }); + // The initial state comes from the thread's own turns: a resumed + // thread may already be running one. + inner.restore_open_snapshot(&response, response_sequence); + inner.finish_open(response_sequence); + let session: Arc = Arc::new(CodexSession { inner, connection }); + Ok(session) + } + fn set_health(&self, health: RuntimeHealth) { self.info.lock().expect("runtime info poisoned").health = health; } @@ -550,104 +647,36 @@ impl HarnessDriver for CodexHarness { fn open<'a>(&'a self, spec: OpenSpec) -> HarnessFuture<'a, Arc, OpenError> { Box::pin(async move { - let connection = self.connection().await?; - let Request { method, params } = - super::delivery::open_request(&spec, self.dynamic_tools()); - // A resume can run input persisted in the native queue and ask for - // approval right away, so the session listens before it loads, and - // the queue it may run is published first. - let early = match &spec.mode { - OpenMode::Resume { session } => { - let inner = SessionInner::new(&connection, session.as_str().to_owned())?; - connection - .sessions - .lock() - .expect("session map poisoned") - .insert(inner.thread.clone(), Arc::downgrade(&inner)); - let _ = inner.refresh_queue().await; - Some(inner) - } - _ => None, - }; - let response = match connection.request(Request { method, params }).await { - Ok(response) => response, - Err(error) => { - if let Some(inner) = &early { - connection - .sessions - .lock() - .expect("session map poisoned") - .remove(&inner.thread); - } - return Err(open_error(error)); - } - }; - let thread = response - .pointer("/thread/id") - .and_then(Value::as_str) - .ok_or_else(|| { - OpenError::Driver(DriverError::Protocol(format!( - "{method} response has no thread id" - ))) - })? - .to_owned(); - let settings = EffectiveSettings { - model: text(response.get("model")).map(|model| DriverSettingOption { - value: model.clone(), - label: model, - description: None, - disabled: false, - }), - effort: text(response.get("reasoningEffort")), - speed: text(response.get("serviceTier")), - permission_mode: text(response.pointer("/activePermissionProfile/id")), - mode: None, - folder: text(response.get("cwd")).map(PathBuf::from), - }; - let inner = match early { - Some(inner) if inner.thread == thread => inner, - _ => { - let inner = SessionInner::new(&connection, thread.clone())?; - connection - .sessions - .lock() - .expect("session map poisoned") - .insert(thread, Arc::downgrade(&inner)); - inner + // Unsubscribe can enter Codex's native shutdown just as the next + // message arrives. Only its explicit "closing" refusal is safe + // to retry: no resume or input was accepted. Every attempt gets + // a fresh early listener, since thread/closed ends the old one. + let deadline = tokio::time::Instant::now() + Duration::from_secs(10); + let mut delay = Duration::from_millis(100); + loop { + let result = self.open_once(&spec).await; + if !resume_is_closing(&spec.mode, &result) + || tokio::time::Instant::now() + delay > deadline + { + return result; } - }; - *inner.model.lock().expect("model poisoned") = - settings.model.as_ref().map(|model| model.value.clone()); - inner.hub.emit(Event::Settings { - effective: settings, - }); - // The initial state comes from the thread's own turns: a resumed - // thread may already be running one. - let (active, finished) = thread_turns(&response); - let (running, consumed) = { - let mut mapper = inner.mapper.lock().expect("mapper poisoned"); - mapper.restore_turns(active.clone(), finished); - ( - mapper.active_turn().is_some(), - mapper.restore_inputs(&response), - ) - }; - for event in consumed { - inner.hub.emit(event); + tokio::time::sleep(delay).await; + delay = (delay * 2).min(Duration::from_secs(1)); } - inner.hub.emit(Event::State { - state: if running { - RunState::Working - } else { - RunState::Idle - }, - }); - let session: Arc = Arc::new(CodexSession { inner, connection }); - Ok(session) }) } } +fn resume_is_closing(mode: &OpenMode, result: &Result) -> bool { + let (OpenMode::Resume { session }, Err(OpenError::Driver(DriverError::Rejected(message)))) = + (mode, result) + else { + return false; + }; + message + == &format!("thread {session} is closing; retry thread/resume after the thread is closed") +} + /// The running and latest finished turn a `thread/*` response reports. fn thread_turns(response: &Value) -> (Option, Option) { let mut active = None; @@ -679,6 +708,8 @@ struct SessionInner { thread: String, hub: EventHub, mapper: StdMutex, + turn_sequence: AtomicU64, + open_boundary: StdMutex, model: StdMutex>, queue: StdMutex>, /// Background terminals still running, from `thread/backgroundTerminals/list`. @@ -686,6 +717,12 @@ struct SessionInner { connection: Weak, } +#[derive(Default)] +struct OpenBoundary { + response: Option, + closed: Option, +} + impl SessionInner { fn new(connection: &Arc, thread: String) -> Result, OpenError> { let key = SessionKey { @@ -697,6 +734,8 @@ impl SessionInner { hub: EventHub::new(key.clone(), DEFAULT_HUB_CAPACITY), key, mapper: StdMutex::new(CodexMapper::new(thread.clone())), + turn_sequence: AtomicU64::new(0), + open_boundary: StdMutex::new(OpenBoundary::default()), thread, model: StdMutex::new(None), queue: StdMutex::new(Vec::new()), @@ -705,6 +744,51 @@ impl SessionInner { })) } + fn restore_open_snapshot(&self, response: &Value, response_sequence: u64) { + let (active, finished) = thread_turns(response); + let mut mapper = self.mapper.lock().expect("mapper poisoned"); + // Snapshot restoration and notification versions share the mapper + // lock, so a completion newer than the response cannot be undone. + if self.turn_sequence.load(Ordering::Acquire) <= response_sequence { + mapper.restore_turns(active, finished); + } + for event in mapper.restore_inputs(response) { + self.hub.emit(event); + } + self.hub.emit(Event::State { + state: if mapper.active_turn().is_some() { + RunState::Working + } else { + RunState::Idle + }, + }); + } + + fn defer_close(&self, sequence: u64) -> bool { + let mut boundary = self.open_boundary.lock().expect("open boundary poisoned"); + if let Some(response) = boundary.response { + return sequence <= response; + } + boundary.closed = Some(sequence); + true + } + + fn finish_open(&self, sequence: u64) { + let closed = { + let mut boundary = self.open_boundary.lock().expect("open boundary poisoned"); + boundary.response = Some(sequence); + boundary + .closed + .take() + .is_some_and(|closed| closed > sequence) + }; + if closed { + self.emit_all(vec![Event::State { + state: RunState::Released, + }]); + } + } + fn emit_all(&self, events: Vec) { for event in events { if let Event::Settings { effective } = &event @@ -724,11 +808,7 @@ impl SessionInner { self.hub.emit(event); // Stop routing only once Codex confirms the thread unloaded. if released && let Some(connection) = self.connection.upgrade() { - connection - .sessions - .lock() - .expect("session map poisoned") - .remove(&self.thread); + connection.remove_session(self); } } } @@ -948,13 +1028,33 @@ async fn dispatch( .filter_map(Weak::upgrade) .collect(); match message { - IncomingMessage::Notification { method, params, .. } => { + IncomingMessage::Notification { + method, + params, + wire_sequence, + } => { for session in &sessions { - let mapped = session - .mapper - .lock() - .expect("mapper poisoned") - .notification(&method, ¶ms); + if method == "thread/closed" + && params.get("threadId").and_then(Value::as_str) + == Some(session.thread.as_str()) + && session.defer_close(wire_sequence) + { + continue; + } + let mapped = { + let mut mapper = session.mapper.lock().expect("mapper poisoned"); + let mapped = mapper.notification(&method, ¶ms); + if mapped + .events + .iter() + .any(|event| matches!(event, Event::Turn { .. })) + { + session + .turn_sequence + .store(wire_sequence, Ordering::Release); + } + mapped + }; let follow = super::suggestion::turn_to_follow(&mapped.events); session.emit_all(mapped.events); if let Some(turn) = follow { @@ -1453,6 +1553,193 @@ fn op_error(error: PeerError) -> OpError { mod tests { use super::*; + #[cfg(unix)] + fn scripted_harness(closing: bool) -> (tempfile::TempDir, CodexHarness) { + use std::os::unix::fs::PermissionsExt; + let dir = tempfile::tempdir().unwrap(); + let executable = dir.path().join("codex"); + let script = r#"#!/bin/bash +[[ "$*" == "app-server" ]] || exit 1 +attempt=0 +while IFS= read -r request; do + [[ "$request" == *'"id":'* ]] || continue + printf '%s\n' "$request" >> "$0.requests" + id=${request#*'"id":'} + id=${id%%[!0-9]*} + case "$request" in + *'"method":"initialize"'*) + printf '{"id":%s,"result":{"userAgent":"codex_app_server/0.166.0"}}\n' "$id" ;; + *'"method":"thread/resume"'*) + attempt=$((attempt+1)) + if [[ $attempt == 1 ]]; then + printf '{"id":%s,"error":{"code":-32600,"message":"REJECTION"}}\n' "$id" + printf '%s\n' '{"method":"thread/closed","params":{"threadId":"thread-1"}}' + else + printf '{"id":%s,"result":{"thread":{"id":"thread-1","turns":[]},"model":"test-model","cwd":"/work"}}\n' "$id" + fi ;; + *'"method":"test/event"'*) + printf '{"id":%s,"result":{}}\n' "$id" + printf '%s\n' '{"method":"thread/name/updated","params":{"threadId":"thread-1","threadName":"still routed"}}' ;; + *'"method":"test/complete"'*) + printf '%s\n' '{"method":"turn/started","params":{"threadId":"thread-1","turn":{"id":"turn-live","status":"inProgress"}}}' + printf '%s\n' '{"method":"turn/completed","params":{"threadId":"thread-1","turn":{"id":"turn-live","status":"completed"}}}' + printf '{"id":%s,"result":{}}\n' "$id" ;; + *) printf '{"id":%s,"result":{"data":[]}}\n' "$id" ;; + esac +done +"#; + let message = if closing { + "thread thread-1 is closing; retry thread/resume after the thread is closed" + } else { + "model is unavailable" + }; + std::fs::write(&executable, script.replace("REJECTION", message)).unwrap(); + std::fs::set_permissions(&executable, std::fs::Permissions::from_mode(0o700)).unwrap(); + let harness = CodexHarness::new(CodexHarnessConfig { + launch: CodexLaunchConfig { + executable, + ..Default::default() + }, + source: ExecutableSource::User, + pinned_sha256: None, + bridge_version: "test".into(), + cache_root: dir.path().join("cache"), + }); + (dir, harness) + } + + fn resume_spec() -> OpenSpec { + OpenSpec { + mode: OpenMode::Resume { + session: ProviderSessionId::new("thread-1").unwrap(), + }, + folder: "/work".into(), + settings: Default::default(), + instructions: None, + title: None, + after: None, + output_mode: Default::default(), + } + } + + #[cfg(unix)] + #[tokio::test] + async fn closing_resume_retries_without_sending_input_and_keeps_event_routing() { + use futures_util::StreamExt; + for late_close in [false, true] { + let (dir, harness) = scripted_harness(true); + if late_close { + let executable = &harness.config.launch.executable; + let script = std::fs::read_to_string(executable).unwrap(); + let close = " printf '%s\\n' '{\"method\":\"thread/closed\",\"params\":{\"threadId\":\"thread-1\"}}'\n"; + let script = script + .replace(close, "") + .replace(" else\n", &format!(" else\n{close}")); + std::fs::write(executable, script).unwrap(); + } + let session = tokio::time::timeout(Duration::from_secs(3), harness.open(resume_spec())) + .await + .unwrap() + .unwrap(); + let mut events = session.events(); + let connection = harness.connection().await.unwrap(); + connection + .request(Request { + method: "test/event", + params: json!({}), + }) + .await + .unwrap(); + tokio::time::timeout(Duration::from_secs(2), async { + while let Some(envelope) = events.next().await { + let event = envelope.event; + assert!(!matches!( + event, + Event::State { + state: RunState::Released + } + )); + if matches!(event, Event::Renamed { title } if title == "still routed") { + return; + } + } + panic!("resumed event stream ended"); + }) + .await + .unwrap(); + let requests = std::fs::read_to_string(dir.path().join("codex.requests")).unwrap(); + assert_eq!(requests.matches("\"method\":\"thread/resume\"").count(), 2); + assert!(!requests.contains("\"method\":\"turn/start\"")); + connection.control.shutdown().await.unwrap(); + } + } + + #[cfg(unix)] + #[tokio::test] + async fn a_completion_newer_than_the_resume_snapshot_is_not_undone() { + use futures_util::StreamExt; + let (_dir, harness) = scripted_harness(true); + let session = harness.open(resume_spec()).await.unwrap(); + let connection = harness.connection().await.unwrap(); + let inner = connection + .sessions + .lock() + .unwrap() + .get("thread-1") + .unwrap() + .upgrade() + .unwrap(); + let response_sequence = inner.open_boundary.lock().unwrap().response.unwrap(); + let mut events = session.events(); + connection + .request(Request { + method: "test/complete", + params: json!({}), + }) + .await + .unwrap(); + tokio::time::timeout(Duration::from_secs(2), async { + while let Some(event) = events.next().await { + if matches!( + event.event, + Event::Turn { + phase: inline_agent_bridge::harness::TurnPhase::Completed { .. }, + .. + } + ) { + return; + } + } + panic!("completion missing"); + }) + .await + .unwrap(); + inner.restore_open_snapshot( + &json!({"thread":{"turns":[{"id":"turn-live","status":"inProgress"}]}}), + response_sequence, + ); + assert!(inner.mapper.lock().unwrap().active_turn().is_none()); + connection.control.shutdown().await.unwrap(); + } + + #[cfg(unix)] + #[tokio::test] + async fn permanent_resume_rejection_is_not_retried() { + let (dir, harness) = scripted_harness(false); + assert!(matches!(harness.open(resume_spec()).await, + Err(OpenError::Driver(DriverError::Rejected(message))) if message == "model is unavailable")); + let requests = std::fs::read_to_string(dir.path().join("codex.requests")).unwrap(); + assert_eq!(requests.matches("\"method\":\"thread/resume\"").count(), 1); + harness + .connection() + .await + .unwrap() + .control + .shutdown() + .await + .unwrap(); + } + #[test] fn skill_options_keep_enabled_skills_once() { let options = skill_options(&serde_json::json!({"data": [ diff --git a/crates/agent-driver-codex/src/harness/mapper.rs b/crates/agent-driver-codex/src/harness/mapper.rs index d363344fb..3a3321f73 100644 --- a/crates/agent-driver-codex/src/harness/mapper.rs +++ b/crates/agent-driver-codex/src/harness/mapper.rs @@ -148,9 +148,7 @@ impl CodexMapper { /// Restores turn facts from a `thread/resume` or `thread/fork` response. pub(crate) fn restore_turns(&mut self, active: Option, finished: Option) { - if active.is_some() { - self.active_turn = active; - } + self.active_turn = active; if finished.is_some() { self.last_finished_turn = finished; } diff --git a/landing/src/docs/content/agents.md b/landing/src/docs/content/agents.md index e80c197d8..0e421b290 100644 --- a/landing/src/docs/content/agents.md +++ b/landing/src/docs/content/agents.md @@ -139,9 +139,12 @@ longer on the machine. For a bridge installed before the new updater, wait until your agents are idle before the first upgrade, then run `inline bridge restart` once using the newly installed executable. -Once enrolled, managed updates wait for active work to finish. Automatic runtime -activations are spaced at least six hours apart, so the terminal and background -bridge can temporarily report different versions. Homebrew-owned CLI executables +Once enrolled, managed updates wait for active work and pending replies to +finish; idle sessions don't hold them back. Automatic runtime activations are +spaced at least six hours apart, so the terminal and background bridge can +temporarily report different versions; running `inline update` yourself switches +the bridge at its next idle moment. `inline bridge status` shows the version the +background bridge runs. Homebrew-owned CLI executables stay managed by Homebrew; the enrolled background bridge can update independently. Check the installed binary and provider paths with `inline bridge doctor --json`. If another CLI installation shadows it on PATH, use the updated executableโ€™s diff --git a/server/src/api-types/api-schema.ts b/server/src/api-types/api-schema.ts index 9b3431e82..5b4f94978 100644 --- a/server/src/api-types/api-schema.ts +++ b/server/src/api-types/api-schema.ts @@ -16,6 +16,7 @@ import type { DbReaction } from "../db/schema/reactions" import { InlineError } from "@in/server/types/errors" import { getSignedMediaPhotoUrl } from "@in/server/modules/files/path" import { encodedDialogOpen } from "@in/server/modules/dialogOpen" +import { displayMessageText } from "@in/server/modules/message/displayText" // const BigIntString = Type.Transform(Type.BigInt()) // .Decode((value) => String(value)) @@ -379,7 +380,7 @@ export const encodeMessageInfo = ( TMessageInfo, Value.Clean(TMessageInfo, { ...message, - text, + text: displayMessageText(text), id: message.messageId, randomId: out && message.randomId ? message.randomId.toString() : undefined, out: out, diff --git a/server/src/modules/message/displayText.ts b/server/src/modules/message/displayText.ts new file mode 100644 index 000000000..a9afe636a --- /dev/null +++ b/server/src/modules/message/displayText.ts @@ -0,0 +1,14 @@ +/** + * Apple clients decode stored text through C strings, so a NUL ends the + * message there and later block ranges stop resolving. U+FFFD is one UTF-16 + * unit as well, so entity and block ranges stay valid. + * + * Apply this only where text leaves the server. Stored text and its + * block-content mirror must stay byte-exact so the mirror check still holds. + */ +export function displayMessageText(text: string): string +export function displayMessageText(text: string | undefined): string | undefined +export function displayMessageText(text: string | null | undefined): string | null | undefined +export function displayMessageText(text: string | null | undefined): string | null | undefined { + return text?.includes("\0") ? text.replaceAll("\0", "๏ฟฝ") : text +} diff --git a/server/src/realtime/encoders/encodeMessage.test.ts b/server/src/realtime/encoders/encodeMessage.test.ts index 4fddf0043..6a872f0f2 100644 --- a/server/src/realtime/encoders/encodeMessage.test.ts +++ b/server/src/realtime/encoders/encodeMessage.test.ts @@ -4,6 +4,7 @@ import type { DbFullMessage } from "@in/server/db/models/messages" import type { DbFullPhoto, DbFullVoice } from "@in/server/db/models/files" import { encodeFullMessage, encodeMessage } from "@in/server/realtime/encoders/encodeMessage" import { + BlockContent, BlockDisclosure_ActivityKind, BlockDisclosure_Kind, MessageEntities, @@ -13,6 +14,10 @@ import { type Peer, } from "@inline-chat/protocol/core" import { encryptBinary } from "@in/server/modules/encryption/encryption" +import { MessageModel, type DbInputFullMessage } from "@in/server/db/models/messages" +import { encryptMessage } from "@in/server/modules/encryption/encryptMessage" +import { encryptStoredBlockContent } from "@in/server/modules/message/blockContentPayload" +import { displayMessageText } from "@in/server/modules/message/displayText" const peer: Peer = { type: { @@ -582,6 +587,104 @@ describe("service messages", () => { }) }) +describe("NUL in message text", () => { + // "before" + NUL? + "๐Ÿš€ " + bold "after"; the code block covers everything after the summary. + const storedProgressRow = (text: string, mirrorText = text) => { + const boldStart = text.indexOf("after") + const entities = MessageEntities.create({ + entities: [{ type: MessageEntity_Type.BOLD, offset: BigInt(boldStart), length: 5n, entity: { oneofKind: undefined } }], + }) + const blockContent = BlockContent.create({ + blocks: [ + { + kind: { + oneofKind: "disclosure", + disclosure: { + summary: { offset: 0n, length: 6n }, + children: [ + { kind: { oneofKind: "code", code: { text: { offset: 6n, length: BigInt(text.length - 6) } } } }, + ], + kind: BlockDisclosure_Kind.PROGRESS, + activityKind: BlockDisclosure_ActivityKind.UNSPECIFIED, + status: 0, + }, + }, + }, + ], + }) + const payload = encryptStoredBlockContent({ text: mirrorText, entities, blockContent }) + const encrypted = encryptMessage(text) + const encryptedEntities = encryptBinary(MessageEntities.toBinary(entities)) + const row: DbInputFullMessage = { + ...buildMessage({ + textEncrypted: encrypted.encrypted, + textIv: encrypted.iv, + textTag: encrypted.authTag, + entitiesEncrypted: encryptedEntities.encrypted, + entitiesIv: encryptedEntities.iv, + entitiesTag: encryptedEntities.authTag, + blockContentId: 1n, + }), + blockContent: { + id: 1n, + payloadEncrypted: payload.encrypted, + payloadIv: payload.iv, + payloadTag: payload.authTag, + schemaVersion: 1, + revision: 0, + createdAt: new Date("2026-10-31T00:00:00Z"), + updatedAt: new Date("2026-10-31T00:00:00Z"), + }, + from: baseUser, + reactions: [], + photo: null, + video: null, + document: null, + voice: null, + messageAttachments: [], + } + return { row, blockContent, entities } + } + + for (const text of ["before๐Ÿš€ after", "before\0๐Ÿš€ after\0"]) { + it(`keeps blocks and ranges on live and fetched messages (${text.includes("\0") ? "NUL" : "control"})`, () => { + const { row, blockContent, entities } = storedProgressRow(text) + const shown = text.replaceAll("\0", "๏ฟฝ") + + const live = encodeMessage({ message: { ...row, blockContent }, encodingForUserId: 100, encodingForPeer: { peer } }) + expect(live.message).toBe(shown) + expect(live.message?.length).toBe(text.length) + expect(live.blockContent).toEqual(blockContent) + + // Storage stays exact, so the block-content mirror still matches. + const processed = MessageModel.processMessage(row) + expect(processed.text).toBe(text) + expect(processed.blockContent).toEqual(blockContent) + + const fetched = encodeFullMessage({ message: processed, encodingForUserId: 100, encodingForPeer: { peer } }) + expect(fetched.message).toBe(shown) + expect(fetched.blockContent).toEqual(blockContent) + expect(fetched.entities).toEqual(entities) + const bold = fetched.entities!.entities[0]! + expect(fetched.message!.slice(Number(bold.offset), Number(bold.offset + bold.length))).toBe("after") + }) + } + + it("still drops blocks whose stored mirror does not match the text", () => { + const { row } = storedProgressRow("before\0๐Ÿš€ after", "before๐Ÿš€ after!") + const processed = MessageModel.processMessage(row) + expect(processed.blockContent).toBeNull() + expect(encodeFullMessage({ message: processed, encodingForUserId: 100, encodingForPeer: { peer } }).blockContent).toBeUndefined() + }) + + it("replaces NUL only for display", () => { + expect(displayMessageText("a\0b\0")).toBe("a๏ฟฝb๏ฟฝ") + expect(displayMessageText("plain")).toBe("plain") + expect(displayMessageText(null)).toBeNull() + expect(displayMessageText(undefined)).toBeUndefined() + }) +}) + describe("encodeMessage via", () => { it("carries the agent that sent the message", () => { const result = encodeMessage({ diff --git a/server/src/realtime/encoders/encodeMessage.ts b/server/src/realtime/encoders/encodeMessage.ts index 1516133ac..e510b475e 100644 --- a/server/src/realtime/encoders/encodeMessage.ts +++ b/server/src/realtime/encoders/encodeMessage.ts @@ -33,6 +33,7 @@ import { decryptBinary } from "@in/server/modules/encryption/encryption" import { detectHasLink } from "@in/server/modules/message/linkDetection" import { isUserMentioned } from "@in/server/modules/message/helpers" import { encodeMessageAttachment } from "@in/server/realtime/encoders/encodeMessageAttachment" +import { displayMessageText } from "@in/server/modules/message/displayText" import type { SystemMessage } from "@in/server/modules/systemMessages" import { projectReadyBlockPhotos } from "@in/server/modules/message/blockContent" @@ -230,7 +231,7 @@ export const encodeMessage = ({ fromId: BigInt(message.fromId), peerId: peerId, chatId: BigInt(message.chatId), - message: text, + message: displayMessageText(text), out: encodingForUserId === message.fromId, date: encodeDateStrict(message.date), editDate: message.editDate ? encodeDateStrict(message.editDate) : undefined, @@ -378,7 +379,7 @@ export const encodeFullMessage = ({ fromId: BigInt(message.fromId), peerId: peerId, chatId: BigInt(message.chatId), - message: message.text ?? undefined, + message: displayMessageText(message.text) ?? undefined, out: encodingForUserId === message.fromId, date: encodeDateStrict(message.date), editDate: message.editDate ? encodeDateStrict(message.editDate) : undefined,