feat(cli): support arbitrary path for sessions (#1414)

crates/goose-cli/src/session/builder.rs

@@ -11,7 +11,7 @@ use super::storage;
 use super::Session;
 
 pub async fn build_session(
-    name: Option<String>,
+    identifier: Option<storage::Identifier>,
     resume: bool,
     extensions: Vec<String>,
     builtins: Vec<String>,
@@ -22,7 +22,6 @@ pub async fn build_session(
     let provider_name: String = config
         .get("GOOSE_PROVIDER")
         .expect("No provider configured. Run 'goose configure' first");
-    let session_dir = storage::ensure_session_dir().expect("Failed to create session directory");
 
     let model: String = config
         .get("GOOSE_MODEL")
@@ -65,13 +64,12 @@ pub async fn build_session(
 
     // Handle session file resolution and resuming
     let session_file = if resume {
-        if let Some(ref session_name) = name {
-            // Try to resume specific named session
-            let session_file = session_dir.join(format!("{}.jsonl", session_name));
+        if let Some(identifier) = identifier {
+            let session_file = storage::get_path(identifier);
             if !session_file.exists() {
                 output::render_error(&format!(
                     "Cannot resume session {} - no such session exists",
-                    style(session_name).cyan()
+                    style(session_file.display()).cyan()
                 ));
                 process::exit(1);
             }
@@ -87,9 +85,13 @@ pub async fn build_session(
             }
         }
     } else {
-        // Create new session with provided or generated name
-        let session_name = name.unwrap_or_else(generate_session_name);
-        create_new_session_file(&session_dir, &session_name)
+        // Create new session with provided name/path or generated name
+        let id = match identifier {
+            Some(identifier) => identifier,
+            None => storage::Identifier::Name(generate_session_name()),
+        };
+        let session_file = storage::get_path(id);
+        create_new_session_file(session_file)
     };
 
     // Create new session
@@ -138,10 +140,9 @@ fn generate_session_name() -> String {
         .collect()
 }
 
-fn create_new_session_file(session_dir: &std::path::Path, name: &str) -> PathBuf {
-    let session_file = session_dir.join(format!("{}.jsonl", name));
+fn create_new_session_file(session_file: PathBuf) -> PathBuf {
     if session_file.exists() {
-        eprintln!("Session '{}' already exists", name);
+        eprintln!("Session '{:?}' already exists", session_file);
         process::exit(1);
     }
     session_file

crates/goose-cli/src/session/mod.rs

@@ -6,6 +6,7 @@ mod storage;
 mod thinking;
 
 pub use builder::build_session;
+pub use storage::Identifier;
 
 use anyhow::Result;
 use etcetera::choose_app_strategy;

crates/goose-cli/src/session/storage.rs

@@ -5,6 +5,21 @@ use std::fs::{self, File};
 use std::io::{self, BufRead, Write};
 use std::path::{Path, PathBuf};
 
+pub enum Identifier {
+    Name(String),
+    Path(PathBuf),
+}
+
+pub fn get_path(id: Identifier) -> PathBuf {
+    match id {
+        Identifier::Name(name) => {
+            let session_dir = ensure_session_dir().expect("Failed to create session directory");
+            session_dir.join(format!("{}.jsonl", name))
+        }
+        Identifier::Path(path) => path,
+    }
+}
+
 /// Ensure the session directory exists and return its path
 pub fn ensure_session_dir() -> Result<PathBuf> {
     let data_dir = choose_app_strategy(crate::APP_STRATEGY.clone())
@@ -71,7 +86,7 @@ pub fn read_messages(session_file: &Path) -> Result<Vec<Message>> {
 ///
 /// Overwrites the file with all messages in JSONL format.
 pub fn persist_messages(session_file: &Path, messages: &[Message]) -> Result<()> {
-    let file = File::create(session_file)?;
+    let file = File::create(session_file).expect("The path specified does not exist");
     let mut writer = io::BufWriter::new(file);
 
     for message in messages {