Resume sessions on launcher restart (#620)

Author: meawoppl

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 2.3.14
+
+- Resume existing Claude sessions on launcher restart instead of creating new ones
+
 ## 2.3.13
 
 - Fix admin stats page crashing on non-401/403 error responses

Cargo.toml

@@ -3,7 +3,7 @@ members = ["shared", "backend", "frontend", "proxy", "claude-session-lib", "laun
 resolver = "2"
 
 [workspace.package]
-version = "2.3.13"
+version = "2.3.14"
 edition = "2021"
 authors = ["Matthew Goodman <d3a6d0cec0c16f3e@inboxnegative.com>"]
 

launcher/src/config.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 use shared::AgentType;
 use std::path::PathBuf;
+use uuid::Uuid;
 
 #[derive(Debug, Deserialize, Serialize, Default)]
 pub struct LauncherConfig {
@@ -20,6 +21,8 @@ pub struct ExpectedSession {
     pub agent_type: AgentType,
     #[serde(default)]
     pub claude_args: Vec<String>,
+    #[serde(default)]
+    pub session_id: Option<Uuid>,
 }
 
 fn config_path() -> PathBuf {
@@ -80,6 +83,24 @@ pub fn add_session(session: &ExpectedSession) -> anyhow::Result<()> {
     save_config(&config)
 }
 
+pub fn update_session_id(working_directory: &str, session_id: Uuid) -> anyhow::Result<()> {
+    let mut config = load_config();
+    if let Some(session) = config
+        .sessions
+        .iter_mut()
+        .find(|s| s.working_directory == working_directory)
+    {
+        session.session_id = Some(session_id);
+        save_config(&config)?;
+        tracing::debug!(
+            "Updated session_id for {}: {}",
+            working_directory,
+            session_id
+        );
+    }
+    Ok(())
+}
+
 pub fn remove_session(working_directory: &str) -> anyhow::Result<()> {
     let mut config = load_config();
     let before = config.sessions.len();
@@ -147,6 +168,7 @@ auth_token = "secret"
                 session_name: Some("my-session".to_string()),
                 agent_type: AgentType::Claude,
                 claude_args: vec!["--verbose".to_string()],
+                session_id: None,
             }],
         };
         let serialized = toml::to_string_pretty(&config).unwrap();
@@ -186,10 +208,50 @@ claude_args = ["--model", "opus"]
         );
         assert_eq!(config.sessions[0].agent_type, AgentType::Claude);
         assert!(config.sessions[0].claude_args.is_empty());
+        assert!(config.sessions[0].session_id.is_none());
 
         assert_eq!(config.sessions[1].working_directory, "/home/user/project-b");
         assert!(config.sessions[1].session_name.is_none());
         assert_eq!(config.sessions[1].agent_type, AgentType::Codex);
         assert_eq!(config.sessions[1].claude_args, vec!["--model", "opus"]);
+        assert!(config.sessions[1].session_id.is_none());
+    }
+
+    #[test]
+    fn parse_config_with_session_id() {
+        let toml = r#"
+backend_url = "wss://example.com"
+auth_token = "tok_abc"
+
+[[sessions]]
+working_directory = "/home/user/project-a"
+session_id = "550e8400-e29b-41d4-a716-446655440000"
+"#;
+        let config: LauncherConfig = toml::from_str(toml).unwrap();
+        assert_eq!(config.sessions.len(), 1);
+        assert_eq!(
+            config.sessions[0].session_id,
+            Some(Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").unwrap())
+        );
+    }
+
+    #[test]
+    fn roundtrip_config_with_session_id() {
+        let sid = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").unwrap();
+        let config = LauncherConfig {
+            backend_url: None,
+            auth_token: None,
+            name: None,
+            sessions: vec![ExpectedSession {
+                working_directory: "/home/user/project".to_string(),
+                session_name: None,
+                agent_type: AgentType::Claude,
+                claude_args: vec![],
+                session_id: Some(sid),
+            }],
+        };
+        let serialized = toml::to_string_pretty(&config).unwrap();
+        let deserialized: LauncherConfig = toml::from_str(&serialized).unwrap();
+        assert_eq!(deserialized.sessions[0].session_id, Some(sid));
     }
 }

launcher/src/connection.rs

@@ -430,7 +430,7 @@ async fn handle_message(
             agent_type,
             ..
         } => {
-            // Check if this is a scheduled launch
+            // Check if this is a scheduled launch or a relaunch of an expected session
             let (resume_session_id, scheduled_task_id, is_scheduled) = if let Some((
                 resume_id,
                 task_id,
@@ -439,7 +439,11 @@ async fn handle_message(
             {
                 (resume_id, Some(task_id), true)
             } else {
-                (None, None, false)
+                let resume_id = expected_sessions
+                    .iter()
+                    .find(|s| s.working_directory == working_directory)
+                    .and_then(|s| s.session_id);
+                (resume_id, None, false)
             };
 
             info!(
@@ -463,23 +467,28 @@ async fn handle_message(
                 Ok(session_id) => {
                     if is_scheduled {
                         scheduler.on_session_spawned(request_id, session_id);
+                    } else if let Some(existing) = expected_sessions
+                        .iter_mut()
+                        .find(|s| s.working_directory == working_directory)
+                    {
+                        // Update stored session_id so future restarts resume this session
+                        existing.session_id = Some(session_id);
+                        if let Err(e) = config::update_session_id(&working_directory, session_id) {
+                            warn!("Failed to update session_id in config: {}", e);
+                        }
                     } else {
-                        // Persist so this session survives launcher restarts
-                        if !expected_sessions
-                            .iter()
-                            .any(|s| s.working_directory == working_directory)
-                        {
-                            let expected = ExpectedSession {
-                                working_directory: working_directory.clone(),
-                                session_name: session_name.clone(),
-                                agent_type,
-                                claude_args: claude_args.clone(),
-                            };
-                            if let Err(e) = config::add_session(&expected) {
-                                warn!("Failed to persist session to config: {}", e);
-                            }
-                            expected_sessions.push(expected);
+                        // New session — persist so it survives launcher restarts
+                        let expected = ExpectedSession {
+                            working_directory: working_directory.clone(),
+                            session_name: session_name.clone(),
+                            agent_type,
+                            claude_args: claude_args.clone(),
+                            session_id: Some(session_id),
+                        };
+                        if let Err(e) = config::add_session(&expected) {
+                            warn!("Failed to persist session to config: {}", e);
                         }
+                        expected_sessions.push(expected);
                     }
                     LauncherToServer::LaunchSessionResult {
                         request_id,