Show inline release notes in update prompt

Fetch GitHub release body metadata during startup update checks and cache concise bullet notes with the latest version. Render those notes directly in the update prompt, falling back to the full release link only when no notes are available.

Tests: CC=clang cargo test -p codex-tui --release update_prompt; CC=clang cargo test -p codex-tui --release release_notes_body_extracts_top_bullets; CC=clang cargo test -p codex-tui --release upgrade_info_preserves_cached_release_notes; just fix -p codex-tui

Co-authored-by: Open Codex <hff582580@gmail.com>

Author: LEON-gittech

codex-rs/tui/src/snapshots/codex_tui__update_prompt__tests__update_prompt_modal.snap

@@ -1,14 +1,17 @@
 ---
 source: tui/src/update_prompt.rs
-assertion_line: 268
+assertion_line: 293
 expression: terminal.backend()
 ---
 
   ✨ Update available! CURRENT_VERSION -> NEXT_VERSION
 
-  Release notes: https://github.com/LEON-gittech/codex
+  What's new:
+    - Fix revoke conversation-only restore scope.
+    - Show concrete release notes in update prompts.
+  Full release notes: https://github.com/LEON-gittech/Open-Codex-CLI/releases/tag/rust-vNEXT_VERSION
 
-› 1. Update now (runs `npm install -g @leonw24/open-codex@latest`)              
+› 1. Update now (runs `npm install -g @leonw24/open-codex@latest`)                                            
   2. Skip
   3. Skip until next version
 

codex-rs/tui/src/update_prompt.rs

@@ -36,15 +36,14 @@ pub(crate) async fn run_update_prompt_if_needed(
     tui: &mut Tui,
     config: &Config,
 ) -> Result<UpdatePromptOutcome> {
-    let Some(latest_version) = updates::get_upgrade_version_for_popup(config).await else {
+    let Some(upgrade_info) = updates::get_upgrade_info_for_popup(config).await else {
         return Ok(UpdatePromptOutcome::Continue);
     };
     let Some(update_action) = crate::update_action::get_update_action() else {
         return Ok(UpdatePromptOutcome::Continue);
     };
 
-    let mut screen =
-        UpdatePromptScreen::new(tui.frame_requester(), latest_version.clone(), update_action);
+    let mut screen = UpdatePromptScreen::new(tui.frame_requester(), upgrade_info, update_action);
     tui.draw(u16::MAX, |frame| {
         frame.render_widget_ref(&screen, frame.area());
     })?;
@@ -92,7 +91,7 @@ enum UpdateSelection {
 
 struct UpdatePromptScreen {
     request_frame: FrameRequester,
-    latest_version: String,
+    upgrade_info: updates::UpgradeInfo,
     current_version: String,
     update_action: UpdateAction,
     highlighted: UpdateSelection,
@@ -102,12 +101,12 @@ struct UpdatePromptScreen {
 impl UpdatePromptScreen {
     fn new(
         request_frame: FrameRequester,
-        latest_version: String,
+        upgrade_info: updates::UpgradeInfo,
         update_action: UpdateAction,
     ) -> Self {
         Self {
             request_frame,
-            latest_version,
+            upgrade_info,
             current_version: env!("CARGO_PKG_VERSION").to_string(),
             update_action,
             highlighted: UpdateSelection::UpdateNow,
@@ -159,7 +158,7 @@ impl UpdatePromptScreen {
     }
 
     fn latest_version(&self) -> &str {
-        self.latest_version.as_str()
+        self.upgrade_info.latest_version.as_str()
     }
 }
 
@@ -187,7 +186,7 @@ impl WidgetRef for &UpdatePromptScreen {
         let mut column = ColumnRenderable::new();
 
         let update_command = self.update_action.command_str();
-        let release_notes_url = self.update_action.release_notes_url();
+        let release_notes_url = self.upgrade_info.release_notes_url.as_str();
 
         column.push("");
         column.push(Line::from(vec![
@@ -197,18 +196,35 @@ impl WidgetRef for &UpdatePromptScreen {
             format!(
                 "{current} -> {latest}",
                 current = self.current_version,
-                latest = self.latest_version
+                latest = self.upgrade_info.latest_version.as_str()
             )
             .dim(),
         ]));
         column.push("");
-        column.push(
-            Line::from(vec![
-                "Release notes: ".dim(),
-                release_notes_url.dim().underlined(),
-            ])
-            .inset(Insets::tlbr(0, 2, 0, 0)),
-        );
+        if self.upgrade_info.release_notes.is_empty() {
+            column.push(
+                Line::from(vec![
+                    "Release notes: ".dim(),
+                    release_notes_url.dim().underlined(),
+                ])
+                .inset(Insets::tlbr(0, 2, 0, 0)),
+            );
+        } else {
+            column.push(Line::from("What's new:".bold()).inset(Insets::tlbr(0, 2, 0, 0)));
+            for note in &self.upgrade_info.release_notes {
+                column.push(
+                    Line::from(vec!["- ".dim(), note.as_str().into()])
+                        .inset(Insets::tlbr(0, 4, 0, 0)),
+                );
+            }
+            column.push(
+                Line::from(vec![
+                    "Full release notes: ".dim(),
+                    release_notes_url.dim().underlined(),
+                ])
+                .inset(Insets::tlbr(0, 2, 0, 0)),
+            );
+        }
         column.push("");
         column.push(selection_option_row(
             0,
@@ -251,7 +267,16 @@ mod tests {
     fn new_prompt() -> UpdatePromptScreen {
         let mut screen = UpdatePromptScreen::new(
             FrameRequester::test_dummy(),
-            "NEXT_VERSION".into(),
+            updates::UpgradeInfo {
+                latest_version: "NEXT_VERSION".into(),
+                release_notes: vec![
+                    "Fix revoke conversation-only restore scope.".into(),
+                    "Show concrete release notes in update prompts.".into(),
+                ],
+                release_notes_url:
+                    "https://github.com/LEON-gittech/Open-Codex-CLI/releases/tag/rust-vNEXT_VERSION"
+                        .into(),
+            },
             UpdateAction::NpmGlobalLatest,
         );
         screen.current_version = "CURRENT_VERSION".into();
@@ -261,7 +286,7 @@ mod tests {
     #[test]
     fn update_prompt_snapshot() {
         let screen = new_prompt();
-        let mut terminal = Terminal::new(VT100Backend::new(80, 12)).expect("terminal");
+        let mut terminal = Terminal::new(VT100Backend::new(110, 14)).expect("terminal");
         terminal
             .draw(|frame| frame.render_widget_ref(&screen, frame.area()))
             .expect("render update prompt");

codex-rs/tui/src/updates.rs

@@ -43,18 +43,39 @@ pub fn get_upgrade_version(config: &Config) -> Option<String> {
     upgrade_version_from_info(info)
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct UpgradeInfo {
+    pub(crate) latest_version: String,
+    pub(crate) release_notes: Vec<String>,
+    pub(crate) release_notes_url: String,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 struct VersionInfo {
     latest_version: String,
+    #[serde(default)]
+    release_notes: Vec<String>,
+    #[serde(default)]
+    release_notes_url: Option<String>,
     // ISO-8601 timestamp (RFC3339)
     last_checked_at: DateTime<Utc>,
     #[serde(default)]
     dismissed_version: Option<String>,
 }
 
+#[derive(Deserialize, Debug)]
+struct GithubReleaseInfo {
+    html_url: Option<String>,
+    body: Option<String>,
+}
+
 const VERSION_FILENAME: &str = "version.json";
 const CACHE_REFRESH_INTERVAL: Duration = Duration::hours(20);
 const STARTUP_UPDATE_CHECK_TIMEOUT: StdDuration = StdDuration::from_secs(3);
+const RELEASE_NOTES_LIMIT: usize = 5;
+const OPEN_CODEX_RELEASES_URL: &str = "https://github.com/LEON-gittech/Open-Codex-CLI/releases";
+const OPEN_CODEX_RELEASE_API_URL_PREFIX: &str =
+    "https://api.github.com/repos/LEON-gittech/Open-Codex-CLI/releases/tags/rust-v";
 
 fn version_filepath(config: &Config) -> PathBuf {
     config.codex_home.join(VERSION_FILENAME).into_path_buf()
@@ -74,12 +95,21 @@ fn should_refresh_version_info(info: Option<&VersionInfo>, now: DateTime<Utc>) -
 }
 
 fn upgrade_version_from_info(info: Option<VersionInfo>) -> Option<String> {
-    info.and_then(|info| {
-        if is_newer(&info.latest_version, CODEX_CLI_VERSION).unwrap_or(false) {
-            Some(info.latest_version)
-        } else {
-            None
-        }
+    upgrade_info_from_info(info).map(|info| info.latest_version)
+}
+
+fn upgrade_info_from_info(info: Option<VersionInfo>) -> Option<UpgradeInfo> {
+    let info = info?;
+    if !is_newer(&info.latest_version, CODEX_CLI_VERSION).unwrap_or(false) {
+        return None;
+    }
+
+    Some(UpgradeInfo {
+        release_notes_url: info
+            .release_notes_url
+            .unwrap_or_else(|| fallback_release_notes_url(&info.latest_version)),
+        latest_version: info.latest_version,
+        release_notes: info.release_notes,
     })
 }
 
@@ -95,11 +125,22 @@ async fn check_for_update(
         .json::<NpmPackageInfo>()
         .await?;
     let latest_version = npm_registry::latest_version(&package_info)?.to_string();
+    let release_notes = fetch_release_notes(&latest_version)
+        .await
+        .unwrap_or_else(|err| {
+            tracing::error!("Failed to fetch release notes for version {latest_version}: {err}");
+            ReleaseNotes {
+                url: fallback_release_notes_url(&latest_version),
+                notes: Vec::new(),
+            }
+        });
 
     // Preserve any previously dismissed version if present.
     let prev_info = read_version_info(version_file).ok();
     let info = VersionInfo {
         latest_version,
+        release_notes: release_notes.notes,
+        release_notes_url: Some(release_notes.url),
         last_checked_at: Utc::now(),
         dismissed_version: prev_info.and_then(|p| p.dismissed_version),
     };
@@ -112,9 +153,77 @@ async fn check_for_update(
     Ok(())
 }
 
+struct ReleaseNotes {
+    url: String,
+    notes: Vec<String>,
+}
+
+async fn fetch_release_notes(version: &str) -> anyhow::Result<ReleaseNotes> {
+    let url = format!("{OPEN_CODEX_RELEASE_API_URL_PREFIX}{version}");
+    let release = create_client()
+        .get(&url)
+        .header(reqwest::header::USER_AGENT, "open-codex-update-check")
+        .send()
+        .await?
+        .error_for_status()?
+        .json::<GithubReleaseInfo>()
+        .await?;
+
+    let notes = release
+        .body
+        .as_deref()
+        .map(release_note_items_from_body)
+        .unwrap_or_default();
+
+    Ok(ReleaseNotes {
+        url: release
+            .html_url
+            .unwrap_or_else(|| fallback_release_notes_url(version)),
+        notes,
+    })
+}
+
+fn fallback_release_notes_url(version: &str) -> String {
+    format!("{OPEN_CODEX_RELEASES_URL}/tag/rust-v{version}")
+}
+
+fn release_note_items_from_body(body: &str) -> Vec<String> {
+    body.lines()
+        .filter_map(|line| {
+            let trimmed = line.trim();
+            trimmed
+                .strip_prefix("- ")
+                .or_else(|| trimmed.strip_prefix("* "))
+        })
+        .map(clean_release_note_item)
+        .filter(|line| !line.is_empty())
+        .take(RELEASE_NOTES_LIMIT)
+        .collect()
+}
+
+fn clean_release_note_item(item: &str) -> String {
+    let mut cleaned = String::with_capacity(item.len());
+    let mut previous_was_space = false;
+    for ch in item.chars() {
+        if ch == '`' {
+            continue;
+        }
+        if ch.is_whitespace() {
+            if !previous_was_space {
+                cleaned.push(' ');
+            }
+            previous_was_space = true;
+        } else {
+            cleaned.push(ch);
+            previous_was_space = false;
+        }
+    }
+    cleaned.trim().to_string()
+}
+
 /// Returns the latest version to show in a popup, if it should be shown.
 /// This respects the user's dismissal choice for the current latest version.
-pub async fn get_upgrade_version_for_popup(config: &Config) -> Option<String> {
+pub async fn get_upgrade_info_for_popup(config: &Config) -> Option<UpgradeInfo> {
     if !config.check_for_update_on_startup || is_source_build_version(CODEX_CLI_VERSION) {
         return None;
     }
@@ -141,14 +250,14 @@ pub async fn get_upgrade_version_for_popup(config: &Config) -> Option<String> {
         }
     }
 
-    let latest = upgrade_version_from_info(info)?;
+    let upgrade_info = upgrade_info_from_info(info)?;
     // If the user dismissed this exact version previously, do not show the popup.
     if let Ok(info) = read_version_info(&version_file)
-        && info.dismissed_version.as_deref() == Some(latest.as_str())
+        && info.dismissed_version.as_deref() == Some(upgrade_info.latest_version.as_str())
     {
         return None;
     }
-    Some(latest)
+    Some(upgrade_info)
 }
 
 /// Persist a dismissal for the current latest version so we don't show
@@ -167,3 +276,56 @@ pub async fn dismiss_version(config: &Config, version: &str) -> anyhow::Result<(
     tokio::fs::write(version_file, json_line).await?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn release_notes_body_extracts_top_bullets() {
+        let body = r#"
+## 0.130.11
+
+- Fix revoke conversation-only restores so they do not touch files.
+- Add inline release notes to the update prompt.
+- Collapse   extra   spacing.
+- Fourth item.
+- Fifth item.
+- Sixth item is ignored.
+
+Details after the list are ignored.
+"#;
+
+        assert_eq!(
+            release_note_items_from_body(body),
+            vec![
+                "Fix revoke conversation-only restores so they do not touch files.".to_string(),
+                "Add inline release notes to the update prompt.".to_string(),
+                "Collapse extra spacing.".to_string(),
+                "Fourth item.".to_string(),
+                "Fifth item.".to_string(),
+            ]
+        );
+    }
+
+    #[test]
+    fn upgrade_info_preserves_cached_release_notes() {
+        let info = VersionInfo {
+            latest_version: "999.0.0".to_string(),
+            release_notes: vec!["One concrete change.".to_string()],
+            release_notes_url: Some("https://example.test/release".to_string()),
+            last_checked_at: Utc::now(),
+            dismissed_version: None,
+        };
+
+        assert_eq!(
+            upgrade_info_from_info(Some(info)),
+            Some(UpgradeInfo {
+                latest_version: "999.0.0".to_string(),
+                release_notes: vec!["One concrete change.".to_string()],
+                release_notes_url: "https://example.test/release".to_string(),
+            })
+        );
+    }
+}