Merge pull request #10182 from gitbutlerapp/stop-session-details-crashes

Stop session details errors

Author: Caleb-T-Owens

crates/but-api/src/commands/claude.rs

@@ -1,7 +1,8 @@
 use std::sync::Arc;
 
+use anyhow::Context;
 use but_api_macros::api_cmd;
-use but_claude::{ClaudeMessage, ModelType, ThinkingLevel, prompt_templates};
+use but_claude::{ClaudeMessage, ModelType, ThinkingLevel, Transcript, prompt_templates};
 use but_settings::AppSettings;
 use but_workspace::StackId;
 use gitbutler_command_context::CommandContext;
@@ -58,21 +59,32 @@ pub fn claude_get_messages(
     Ok(messages)
 }
 
-#[api_cmd]
 #[tauri::command(async)]
 #[instrument(err(Debug))]
-pub fn claude_get_session_details(
+pub async fn claude_get_session_details(
     project_id: ProjectId,
     session_id: String,
 ) -> Result<but_claude::ClaudeSessionDetails, Error> {
     let project = gitbutler_project::get(project_id)?;
+    let mut ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
     let session_id = uuid::Uuid::parse_str(&session_id).map_err(anyhow::Error::from)?;
-    let transcript_path = but_claude::Transcript::get_transcript_path(&project.path, session_id)?;
-    let transcript = but_claude::Transcript::from_file(&transcript_path)?;
-    Ok(but_claude::ClaudeSessionDetails {
-        summary: transcript.summary(),
-        last_prompt: transcript.prompt(),
-    })
+    let session = but_claude::db::get_session_by_id(&mut ctx, session_id)?
+        .context("Could not find session")?;
+    let current_id = Transcript::current_valid_session_id(&project.path, &session).await?;
+    if let Some(current_id) = current_id {
+        let transcript_path =
+            but_claude::Transcript::get_transcript_path(&project.path, current_id)?;
+        let transcript = but_claude::Transcript::from_file(&transcript_path)?;
+        Ok(but_claude::ClaudeSessionDetails {
+            summary: transcript.summary(),
+            last_prompt: transcript.prompt(),
+        })
+    } else {
+        Ok(but_claude::ClaudeSessionDetails {
+            summary: None,
+            last_prompt: None,
+        })
+    }
 }
 
 #[api_cmd]

crates/but-claude/src/bridge.rs

@@ -33,12 +33,10 @@ use serde_json::json;
 use std::{
     collections::HashMap,
     io::{BufRead, BufReader, PipeReader, Read as _},
-    path::Path,
     process::ExitStatus,
     sync::Arc,
 };
 use tokio::{
-    fs,
     process::{Child, Command},
     sync::{
         Mutex,
@@ -373,22 +371,7 @@ async fn spawn_command(
         command.args(["--permission-mode", "acceptEdits"]);
     }
 
-    let mut session_ids = session.session_ids.clone();
-    let mut current_id = None;
-
-    loop {
-        if session_ids.is_empty() {
-            break;
-        }
-
-        let next_id = session_ids.pop();
-        if let Some(next_id) = next_id
-            && transcript_exists_and_likely_valid(&project_path, next_id).await?
-        {
-            current_id = Some(next_id);
-            break;
-        }
-    }
+    let current_id = Transcript::current_valid_session_id(&project_path, &session).await?;
 
     if let Some(current_id) = current_id {
         command.args(["--resume", &format!("{current_id}")]);
@@ -400,22 +383,6 @@ async fn spawn_command(
     Ok(command.spawn()?)
 }
 
-async fn transcript_exists_and_likely_valid(
-    project_path: &Path,
-    session_id: uuid::Uuid,
-) -> Result<bool> {
-    let path = Transcript::get_transcript_path(project_path, session_id)?;
-    if fs::try_exists(&path).await? {
-        let file = fs::read_to_string(&path).await?;
-        // Sometimes a transcript gets written out that only as a summary and is
-        // only 1 line long. These can be considered invalid sessions
-        if file.lines().count() > 1 {
-            return Ok(true);
-        }
-    }
-    Ok(false)
-}
-
 fn format_message(message: &str, thinking_level: ThinkingLevel) -> String {
     match thinking_level {
         ThinkingLevel::Normal => message.to_owned(),

crates/but-claude/src/claude_transcript.rs

@@ -5,6 +5,9 @@ use std::{
     io::BufRead,
     path::{Path, PathBuf},
 };
+use tokio::fs;
+
+use crate::ClaudeSession;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct UserMessage {
@@ -83,6 +86,30 @@ pub struct Transcript {
 }
 
 impl Transcript {
+    pub async fn current_valid_session_id(
+        path: &Path,
+        session: &ClaudeSession,
+    ) -> Result<Option<uuid::Uuid>> {
+        let mut session_ids = session.session_ids.clone();
+        let mut current_id = None;
+
+        loop {
+            if session_ids.is_empty() {
+                break;
+            }
+
+            let next_id = session_ids.pop();
+            if let Some(next_id) = next_id
+                && Self::transcript_exists_and_likely_valid(path, next_id).await?
+            {
+                current_id = Some(next_id);
+                break;
+            }
+        }
+
+        Ok(current_id)
+    }
+
     pub fn from_file(path: &Path) -> Result<Self> {
         let records = Transcript::from_file_raw(path)?
             .into_iter()
@@ -174,4 +201,20 @@ impl Transcript {
         }
         None
     }
+
+    async fn transcript_exists_and_likely_valid(
+        project_path: &Path,
+        session_id: uuid::Uuid,
+    ) -> Result<bool> {
+        let path = Self::get_transcript_path(project_path, session_id)?;
+        if fs::try_exists(&path).await? {
+            let file = fs::read_to_string(&path).await?;
+            // Sometimes a transcript gets written out that only as a summary and is
+            // only 1 line long. These can be considered invalid sessions
+            if file.lines().count() > 1 {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
 }

crates/but-server/src/lib.rs

@@ -21,6 +21,7 @@ use but_api::{
 use but_broadcaster::Broadcaster;
 use but_settings::AppSettingsWithDiskSync;
 use futures_util::{SinkExt, StreamExt as _};
+use gitbutler_project::ProjectId;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use tokio::sync::Mutex;
@@ -421,7 +422,25 @@ async fn handle_command(
                 Err(e) => Err(e),
             }
         }
-        "claude_get_session_details" => claude::claude_get_session_details_cmd(request.params),
+        "claude_get_session_details" => {
+            #[derive(Deserialize)]
+            #[serde(rename_all = "camelCase")]
+            struct Params {
+                project_id: ProjectId,
+                session_id: String,
+            }
+            let params = serde_json::from_value(request.params).to_error();
+            match params {
+                Ok(Params {
+                    project_id,
+                    session_id,
+                }) => {
+                    let result = claude::claude_get_session_details(project_id, session_id).await;
+                    result.map(|r| json!(r))
+                }
+                Err(e) => Err(e),
+            }
+        }
         "claude_list_permission_requests" => {
             claude::claude_list_permission_requests_cmd(request.params)
         }