handoff-mcp-server 0.4.0 → 0.6.0

package/src/storage/sessions.rs

@@ -7,6 +7,8 @@ use serde_json::Value;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SessionData {
     pub version: u32,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ended_at: Option<String>,
     pub summary: String,
@@ -32,6 +34,11 @@ pub struct SessionData {
     pub environment: Option<Value>,
 }
 
+pub fn generate_session_id() -> String {
+    let now = chrono::Utc::now();
+    format!("s-{}", now.format("%Y%m%d-%H%M%S-%6f"))
+}
+
 pub fn generate_session_filename(summary: &str, timestamp: &str) -> String {
     let slug = summary_to_slug(summary);
     format!("{timestamp}-{slug}")
@@ -72,53 +79,57 @@ fn summary_to_slug(summary: &str) -> String {
     }
 }
 
-pub fn write_active_session(sessions_dir: &Path, data: &SessionData) -> Result<PathBuf> {
+fn compact_timestamp(data: &SessionData) -> String {
     let timestamp = data.ended_at.as_deref().unwrap_or("00000000-000000");
     let ts_compact = timestamp
         .replace(['-', ':'], "")
         .replace('T', "-")
         .replace('Z', "");
-    let ts_part = if ts_compact.len() >= 15 {
-        &ts_compact[..15]
+    if ts_compact.len() >= 15 {
+        ts_compact[..15].to_string()
     } else {
-        &ts_compact
-    };
-
-    let base = generate_session_filename(&data.summary, ts_part);
-    let filename = format!("{base}.active.json");
-    let path = sessions_dir.join(&filename);
-
-    let content = serde_json::to_string_pretty(data).context("Failed to serialize session")?;
-    std::fs::write(&path, content)
-        .with_context(|| format!("Failed to write session: {}", path.display()))?;
-
-    Ok(path)
+        ts_compact
+    }
 }
 
-pub fn close_active_sessions(sessions_dir: &Path) -> Result<Vec<PathBuf>> {
-    let mut closed = Vec::new();
+fn synthesize_id_from_filename(filename: &str) -> String {
+    // Old format: YYYYMMDD-HHMMSS-slug.status.json
+    // Extract timestamp part and create s-YYYYMMDD-HHMMSS-000000
+    let base = filename
+        .rsplit_once('.')
+        .and_then(|(rest, _)| rest.rsplit_once('.'))
+        .map(|(rest, _)| rest)
+        .unwrap_or(filename);
 
-    if !sessions_dir.exists() {
-        return Ok(closed);
+    if base.len() >= 15 {
+        let ts = &base[..15]; // YYYYMMDD-HHMMSS
+        format!("s-{ts}-000000")
+    } else {
+        format!("s-{base}-000000")
     }
+}
 
-    for entry in std::fs::read_dir(sessions_dir)? {
-        let entry = entry?;
-        let name = entry.file_name().to_string_lossy().to_string();
-        if name.ends_with(".active.json") {
-            let new_name = name.replace(".active.json", ".closed.json");
-            let new_path = sessions_dir.join(&new_name);
-            std::fs::rename(entry.path(), &new_path)
-                .with_context(|| format!("Failed to close session: {}", entry.path().display()))?;
-            closed.push(new_path);
-        }
+pub fn write_open_session(sessions_dir: &Path, data: &SessionData) -> Result<PathBuf> {
+    let mut data = data.clone();
+    if data.id.is_none() {
+        data.id = Some(generate_session_id());
     }
 
-    Ok(closed)
+    let ts_part = compact_timestamp(&data);
+    let base = generate_session_filename(&data.summary, &ts_part);
+    let filename = format!("{base}.open.json");
+    let path = sessions_dir.join(&filename);
+
+    let content = serde_json::to_string_pretty(&data).context("Failed to serialize session")?;
+    std::fs::write(&path, content)
+        .with_context(|| format!("Failed to write session: {}", path.display()))?;
+
+    Ok(path)
 }
 
-pub fn read_active_sessions(sessions_dir: &Path) -> Result<Vec<SessionData>> {
+pub fn read_sessions_by_status(sessions_dir: &Path, status: &str) -> Result<Vec<SessionData>> {
     let mut sessions = Vec::new();
+    let suffix = format!(".{status}.json");
 
     if !sessions_dir.exists() {
         return Ok(sessions);
@@ -131,11 +142,14 @@ pub fn read_active_sessions(sessions_dir: &Path) -> Result<Vec<SessionData>> {
 
     for entry in entries {
         let name = entry.file_name().to_string_lossy().to_string();
-        if name.ends_with(".active.json") {
+        if name.ends_with(&suffix) {
             let content = std::fs::read_to_string(entry.path())
                 .with_context(|| format!("Failed to read session: {}", entry.path().display()))?;
-            let data: SessionData = serde_json::from_str(&content)
+            let mut data: SessionData = serde_json::from_str(&content)
                 .with_context(|| format!("Failed to parse session: {}", entry.path().display()))?;
+            if data.id.is_none() {
+                data.id = Some(synthesize_id_from_filename(&name));
+            }
             sessions.push(data);
         }
     }
@@ -143,6 +157,114 @@ pub fn read_active_sessions(sessions_dir: &Path) -> Result<Vec<SessionData>> {
     Ok(sessions)
 }
 
+pub fn read_open_sessions(sessions_dir: &Path) -> Result<Vec<SessionData>> {
+    read_sessions_by_status(sessions_dir, "open")
+}
+
+pub fn read_active_sessions(sessions_dir: &Path) -> Result<Vec<SessionData>> {
+    read_sessions_by_status(sessions_dir, "active")
+}
+
+fn transition_sessions(sessions_dir: &Path, from: &str, to: &str) -> Result<Vec<PathBuf>> {
+    let mut transitioned = Vec::new();
+    let from_suffix = format!(".{from}.json");
+    let to_suffix = format!(".{to}.json");
+
+    if !sessions_dir.exists() {
+        return Ok(transitioned);
+    }
+
+    for entry in std::fs::read_dir(sessions_dir)? {
+        let entry = entry?;
+        let name = entry.file_name().to_string_lossy().to_string();
+        if name.ends_with(&from_suffix) {
+            let new_name = name.replace(&from_suffix, &to_suffix);
+            let new_path = sessions_dir.join(&new_name);
+            std::fs::rename(entry.path(), &new_path).with_context(|| {
+                format!(
+                    "Failed to transition session {from}->{to}: {}",
+                    entry.path().display()
+                )
+            })?;
+            transitioned.push(new_path);
+        }
+    }
+
+    Ok(transitioned)
+}
+
+fn transition_session_by_id(
+    sessions_dir: &Path,
+    session_id: &str,
+    from: &str,
+    to: &str,
+) -> Result<Option<PathBuf>> {
+    let from_suffix = format!(".{from}.json");
+    let to_suffix = format!(".{to}.json");
+
+    if !sessions_dir.exists() {
+        return Ok(None);
+    }
+
+    for entry in std::fs::read_dir(sessions_dir)? {
+        let entry = entry?;
+        let name = entry.file_name().to_string_lossy().to_string();
+        if !name.ends_with(&from_suffix) {
+            continue;
+        }
+
+        let content = std::fs::read_to_string(entry.path())
+            .with_context(|| format!("Failed to read session: {}", entry.path().display()))?;
+        let data: SessionData = serde_json::from_str(&content)
+            .with_context(|| format!("Failed to parse session: {}", entry.path().display()))?;
+
+        let file_id = data.id.as_deref().unwrap_or("").to_string();
+        let synthesized = if file_id.is_empty() {
+            synthesize_id_from_filename(&name)
+        } else {
+            file_id
+        };
+
+        if synthesized == session_id {
+            let new_name = name.replace(&from_suffix, &to_suffix);
+            let new_path = sessions_dir.join(&new_name);
+            std::fs::rename(entry.path(), &new_path).with_context(|| {
+                format!(
+                    "Failed to transition session {from}->{to}: {}",
+                    entry.path().display()
+                )
+            })?;
+            return Ok(Some(new_path));
+        }
+    }
+
+    Ok(None)
+}
+
+pub fn activate_open_sessions(sessions_dir: &Path) -> Result<Vec<PathBuf>> {
+    transition_sessions(sessions_dir, "open", "active")
+}
+
+pub fn activate_session_by_id(sessions_dir: &Path, session_id: &str) -> Result<Option<PathBuf>> {
+    transition_session_by_id(sessions_dir, session_id, "open", "active")
+}
+
+pub fn close_active_sessions(sessions_dir: &Path) -> Result<Vec<PathBuf>> {
+    transition_sessions(sessions_dir, "active", "closed")
+}
+
+pub fn close_open_sessions(sessions_dir: &Path) -> Result<Vec<PathBuf>> {
+    transition_sessions(sessions_dir, "open", "closed")
+}
+
+pub fn close_session_by_id(sessions_dir: &Path, session_id: &str) -> Result<Option<PathBuf>> {
+    // Try active first, then open
+    if let Some(path) = transition_session_by_id(sessions_dir, session_id, "active", "closed")? {
+        return Ok(Some(path));
+    }
+    transition_session_by_id(sessions_dir, session_id, "open", "closed")
+}
+
 pub fn enforce_history_limit(sessions_dir: &Path, limit: u32) -> Result<u32> {
     if !sessions_dir.exists() {
         return Ok(0);
@@ -172,3 +294,9 @@ pub fn enforce_history_limit(sessions_dir: &Path, limit: u32) -> Result<u32> {
 
     Ok(removed)
 }
+
+// Backward-compatible aliases for tests and migration
+#[doc(hidden)]
+pub fn write_active_session(sessions_dir: &Path, data: &SessionData) -> Result<PathBuf> {
+    write_open_session(sessions_dir, data)
+}

package/tests/storage_sessions.rs

@@ -9,6 +9,7 @@ fn setup() -> TempDir {
 fn make_session(summary: &str, ended_at: &str) -> SessionData {
     SessionData {
         version: 2,
+        id: None,
         ended_at: Some(ended_at.to_string()),
         summary: summary.to_string(),
         branch: Some("main".to_string()),
@@ -25,17 +26,17 @@ fn make_session(summary: &str, ended_at: &str) -> SessionData {
 }
 
 #[test]
-fn write_active_session_creates_file() {
+fn write_open_session_creates_file() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
     let data = make_session("test session", "2026-06-13T14:30:00Z");
-    let path = write_active_session(&sessions_dir, &data).unwrap();
+    let path = write_open_session(&sessions_dir, &data).unwrap();
 
     assert!(path.exists());
     assert!(
-        path.to_string_lossy().ends_with(".active.json"),
+        path.to_string_lossy().ends_with(".open.json"),
         "filename: {}",
         path.display()
     );
@@ -47,26 +48,26 @@ fn write_active_session_creates_file() {
 }
 
 #[test]
-fn read_active_sessions_empty() {
+fn read_open_sessions_empty() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
-    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
     assert!(sessions.is_empty());
 }
 
 #[test]
-fn read_active_sessions_returns_active_only() {
+fn read_open_sessions_returns_open_only() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
-    let s1 = make_session("active one", "2026-06-13T10:00:00Z");
-    write_active_session(&sessions_dir, &s1).unwrap();
+    let s1 = make_session("open one", "2026-06-13T10:00:00Z");
+    write_open_session(&sessions_dir, &s1).unwrap();
 
-    let s2 = make_session("active two", "2026-06-13T11:00:00Z");
-    write_active_session(&sessions_dir, &s2).unwrap();
+    let s2 = make_session("open two", "2026-06-13T11:00:00Z");
+    write_open_session(&sessions_dir, &s2).unwrap();
 
     fs::write(
         sessions_dir.join("20260612-090000-old.closed.json"),
@@ -74,10 +75,26 @@ fn read_active_sessions_returns_active_only() {
     )
     .unwrap();
 
-    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
     assert_eq!(sessions.len(), 2);
 }
 
+#[test]
+fn activate_open_sessions_renames_to_active() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-13T10:00:00Z");
+    let open_path = write_open_session(&sessions_dir, &s1).unwrap();
+
+    let activated = activate_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(activated.len(), 1);
+    assert!(!open_path.exists());
+    assert!(activated[0].exists());
+    assert!(activated[0].to_string_lossy().contains(".active.json"));
+}
+
 #[test]
 fn close_active_sessions_renames_to_closed() {
     let dir = setup();
@@ -85,7 +102,9 @@ fn close_active_sessions_renames_to_closed() {
     fs::create_dir_all(&sessions_dir).unwrap();
 
     let s1 = make_session("session one", "2026-06-13T10:00:00Z");
-    let active_path = write_active_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s1).unwrap();
+    let activated = activate_open_sessions(&sessions_dir).unwrap();
+    let active_path = &activated[0];
 
     let closed = close_active_sessions(&sessions_dir).unwrap();
     assert_eq!(closed.len(), 1);
@@ -95,22 +114,51 @@ fn close_active_sessions_renames_to_closed() {
 }
 
 #[test]
-fn close_active_then_create_new() {
+fn close_open_sessions_renames_to_closed() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-13T10:00:00Z");
+    let open_path = write_open_session(&sessions_dir, &s1).unwrap();
+
+    let closed = close_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(closed.len(), 1);
+    assert!(!open_path.exists());
+    assert!(closed[0].exists());
+    assert!(closed[0].to_string_lossy().contains(".closed.json"));
+}
+
+#[test]
+fn full_session_lifecycle_open_active_closed() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
 
     let s1 = make_session("first session", "2026-06-13T10:00:00Z");
-    write_active_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s1).unwrap();
 
-    close_active_sessions(&sessions_dir).unwrap();
+    let open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(open.len(), 1);
+    assert_eq!(open[0].summary, "first session");
 
-    let s2 = make_session("second session", "2026-06-13T14:00:00Z");
-    write_active_session(&sessions_dir, &s2).unwrap();
+    activate_open_sessions(&sessions_dir).unwrap();
 
+    assert!(read_open_sessions(&sessions_dir).unwrap().is_empty());
     let active = read_active_sessions(&sessions_dir).unwrap();
     assert_eq!(active.len(), 1);
-    assert_eq!(active[0].summary, "second session");
+    assert_eq!(active[0].summary, "first session");
+
+    close_active_sessions(&sessions_dir).unwrap();
+
+    assert!(read_active_sessions(&sessions_dir).unwrap().is_empty());
+
+    let s2 = make_session("second session", "2026-06-13T14:00:00Z");
+    write_open_session(&sessions_dir, &s2).unwrap();
+
+    let open2 = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(open2.len(), 1);
+    assert_eq!(open2[0].summary, "second session");
 }
 
 #[test]
@@ -140,7 +188,7 @@ fn enforce_history_limit_removes_oldest() {
 }
 
 #[test]
-fn enforce_history_limit_ignores_active() {
+fn enforce_history_limit_ignores_open_and_active() {
     let dir = setup();
     let sessions_dir = dir.path().join("sessions");
     fs::create_dir_all(&sessions_dir).unwrap();
@@ -154,13 +202,13 @@ fn enforce_history_limit_ignores_active() {
         .unwrap();
     }
 
-    let s = make_session("active", "2026-06-13T10:00:00Z");
-    write_active_session(&sessions_dir, &s).unwrap();
+    let s = make_session("open session", "2026-06-13T10:00:00Z");
+    write_open_session(&sessions_dir, &s).unwrap();
 
     enforce_history_limit(&sessions_dir, 2).unwrap();
 
-    let active = read_active_sessions(&sessions_dir).unwrap();
-    assert_eq!(active.len(), 1);
+    let open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(open.len(), 1);
 }
 
 #[test]
@@ -187,9 +235,125 @@ fn generate_session_filename_format() {
 }
 
 #[test]
-fn read_active_sessions_nonexistent_dir() {
+fn read_open_sessions_nonexistent_dir() {
     let dir = setup();
     let sessions_dir = dir.path().join("nonexistent");
-    let sessions = read_active_sessions(&sessions_dir).unwrap();
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
     assert!(sessions.is_empty());
 }
+
+#[test]
+fn generate_session_id_format() {
+    let id = generate_session_id();
+    assert!(id.starts_with("s-"), "should start with s-: {id}");
+    assert!(id.len() > 20, "should be long enough: {id}");
+    let parts: Vec<&str> = id.splitn(2, '-').collect();
+    assert_eq!(parts[0], "s");
+}
+
+#[test]
+fn write_open_session_assigns_id() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s = make_session("test", "2026-06-15T10:00:00Z");
+    assert!(s.id.is_none());
+
+    write_open_session(&sessions_dir, &s).unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 1);
+    assert!(
+        sessions[0].id.is_some(),
+        "written session should have an id"
+    );
+    assert!(sessions[0].id.as_ref().unwrap().starts_with("s-"));
+}
+
+#[test]
+fn read_old_session_without_id_gets_synthesized_id() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    // Write a session file without id field (simulating pre-upgrade file)
+    fs::write(
+        sessions_dir.join("20260613-143000-old-session.open.json"),
+        r#"{"version":2,"summary":"old session"}"#,
+    )
+    .unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 1);
+    assert!(
+        sessions[0].id.is_some(),
+        "old session should get a synthesized id"
+    );
+    let id = sessions[0].id.as_ref().unwrap();
+    assert!(id.starts_with("s-"), "synthesized id format: {id}");
+    assert!(
+        id.contains("20260613-143000"),
+        "synthesized id should contain original timestamp: {id}"
+    );
+}
+
+#[test]
+fn close_session_by_id_closes_only_targeted() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-15T10:00:00Z");
+    let s2 = make_session("session two", "2026-06-15T11:00:00Z");
+    write_open_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s2).unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(sessions.len(), 2);
+
+    let target_id = sessions[0].id.as_ref().unwrap().clone();
+    let other_id = sessions[1].id.as_ref().unwrap().clone();
+
+    let result = close_session_by_id(&sessions_dir, &target_id).unwrap();
+    assert!(result.is_some(), "should close the targeted session");
+
+    let remaining_open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(remaining_open.len(), 1);
+    assert_eq!(remaining_open[0].id.as_deref().unwrap(), other_id);
+}
+
+#[test]
+fn activate_session_by_id_activates_only_targeted() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let s1 = make_session("session one", "2026-06-15T10:00:00Z");
+    let s2 = make_session("session two", "2026-06-15T11:00:00Z");
+    write_open_session(&sessions_dir, &s1).unwrap();
+    write_open_session(&sessions_dir, &s2).unwrap();
+
+    let sessions = read_open_sessions(&sessions_dir).unwrap();
+    let target_id = sessions[0].id.as_ref().unwrap().clone();
+
+    let result = activate_session_by_id(&sessions_dir, &target_id).unwrap();
+    assert!(result.is_some(), "should activate the targeted session");
+
+    let remaining_open = read_open_sessions(&sessions_dir).unwrap();
+    assert_eq!(remaining_open.len(), 1, "one session should remain open");
+
+    let active = read_active_sessions(&sessions_dir).unwrap();
+    assert_eq!(active.len(), 1, "one session should be active");
+    assert_eq!(active[0].id.as_deref().unwrap(), target_id);
+}
+
+#[test]
+fn close_session_by_id_nonexistent_returns_none() {
+    let dir = setup();
+    let sessions_dir = dir.path().join("sessions");
+    fs::create_dir_all(&sessions_dir).unwrap();
+
+    let result = close_session_by_id(&sessions_dir, "s-nonexistent").unwrap();
+    assert!(result.is_none());
+}

package/tests/tool_import_context.rs

@@ -360,7 +360,7 @@ fn import_source_recorded_in_environment() {
     let entries: Vec<_> = std::fs::read_dir(&sessions_dir)
         .unwrap()
         .filter_map(|e| e.ok())
-        .filter(|e| e.file_name().to_string_lossy().ends_with(".active.json"))
+        .filter(|e| e.file_name().to_string_lossy().ends_with(".open.json"))
         .collect();
     assert_eq!(entries.len(), 1);