handoff-mcp-server 0.7.0 → 0.7.2

package/Cargo.lock

@@ -144,7 +144,7 @@ dependencies = [
 
 [[package]]
 name = "handoff-mcp"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "handoff-mcp"
-version = "0.7.0"
+version = "0.7.2"
 edition = "2021"
 description = "MCP server that gives AI coding agents persistent memory across sessions"
 license = "MIT"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "handoff-mcp-server",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "MCP server that gives AI coding agents persistent memory across sessions",
   "license": "MIT",
   "author": "AlphaElements <66808803+alphaelements@users.noreply.github.com>",
@@ -24,10 +24,9 @@
     "postinstall": "node scripts/postinstall.js"
   },
   "files": [
-    "bin/",
+    "bin/handoff-mcp.js",
     "scripts/",
     "src/",
-    "tests/",
     "Cargo.toml",
     "Cargo.lock",
     "LICENSE",

package/scripts/postinstall.js

@@ -10,7 +10,13 @@ const BIN_DIR = path.join(ROOT, "bin");
 const BINARY = path.join(BIN_DIR, "handoff-mcp-bin");
 
 if (fs.existsSync(BINARY)) {
-  process.exit(0);
+  try {
+    execSync(`"${BINARY}" --help`, { stdio: "ignore", timeout: 5000 });
+    process.exit(0);
+  } catch {
+    // prebuilt binary exists but can't run on this platform — rebuild
+    fs.unlinkSync(BINARY);
+  }
 }
 
 try {

package/src/mcp/handlers/load_context.rs

@@ -5,8 +5,8 @@ use super::resolve_project_dir;
 use crate::storage::config::read_config;
 use crate::storage::referrals::read_referral_summaries;
 use crate::storage::sessions::{
-    activate_open_sessions, activate_session_by_id, read_open_sessions, read_paused_sessions,
-    resume_paused_session_by_id,
+    activate_open_sessions, activate_session_by_id, read_active_sessions, read_open_sessions,
+    read_paused_sessions, resume_paused_session_by_id,
 };
 use crate::storage::tasks::build_task_index;
 use crate::storage::{ensure_handoff_exists, handoff_dir};
@@ -39,11 +39,30 @@ pub fn handle(arguments: &Value) -> Result<String> {
 
     let target_session_id = arguments.get("session_id").and_then(|v| v.as_str());
 
+    let active_sessions = read_active_sessions(&sessions_dir)?;
     let sessions = read_open_sessions(&sessions_dir)?;
     let paused_sessions = read_paused_sessions(&sessions_dir)?;
 
     let selected_session = if let Some(sid) = target_session_id {
-        if activate_session_by_id(&sessions_dir, sid)?.is_some() {
+        let already_active = active_sessions
+            .iter()
+            .any(|s| s.id.as_deref().is_some_and(|id| id == sid));
+        if already_active {
+            active_sessions
+                .into_iter()
+                .find(|s| s.id.as_deref().is_some_and(|id| id == sid))
+        } else if !active_sessions.is_empty() {
+            let active_ids: Vec<String> = active_sessions
+                .iter()
+                .filter_map(|s| s.id.clone())
+                .collect();
+            anyhow::bail!(
+                "Cannot activate session '{sid}': another session is already active ({}).\n\
+                 Use save_context with close_session_id or pause_session_id to \
+                 close/pause the active session first.",
+                active_ids.join(", ")
+            );
+        } else if activate_session_by_id(&sessions_dir, sid)?.is_some() {
             sessions
                 .into_iter()
                 .find(|s| s.id.as_deref().is_some_and(|id| id == sid))
@@ -54,6 +73,16 @@ pub fn handle(arguments: &Value) -> Result<String> {
         } else {
             None
         }
+    } else if !active_sessions.is_empty() {
+        active_sessions.into_iter().last()
+    } else if sessions.len() > 1 {
+        let open_ids: Vec<String> = sessions.iter().filter_map(|s| s.id.clone()).collect();
+        anyhow::bail!(
+            "Multiple open sessions found ({}).\n\
+             Specify session_id to choose one, or use save_context to \
+             close/pause the others first.",
+            open_ids.join(", ")
+        );
     } else {
         activate_open_sessions(&sessions_dir)?;
         sessions.into_iter().last()

package/src/mcp/handlers/save_context.rs

@@ -10,8 +10,8 @@ use crate::storage::ensure_handoff_exists;
 use crate::storage::git::capture_git_state;
 use crate::storage::sessions::{
     close_active_sessions, close_open_sessions, close_session_by_id, enforce_history_limit,
-    generate_session_id, pause_active_sessions, pause_session_by_id, write_open_session,
-    SessionData,
+    generate_session_id, pause_active_sessions, pause_session_by_id, read_active_sessions,
+    write_open_session, SessionData,
 };
 
 pub fn handle(arguments: &Value) -> Result<String> {
@@ -53,6 +53,16 @@ pub fn handle(arguments: &Value) -> Result<String> {
         let closed_open = close_open_sessions(&sessions_dir)?;
         closed_open.len()
     } else {
+        let active = read_active_sessions(&sessions_dir)?;
+        if active.len() > 1 {
+            let active_ids: Vec<String> = active.iter().filter_map(|s| s.id.clone()).collect();
+            anyhow::bail!(
+                "Multiple active sessions found ({}).\n\
+                 Use close_session_id or pause_session_id to specify which to \
+                 close/pause before saving a new session.",
+                active_ids.join(", ")
+            );
+        }
         let closed_active = close_active_sessions(&sessions_dir)?;
         let closed_open = close_open_sessions(&sessions_dir)?;
         closed_active.len() + closed_open.len()

package/tests/mcp_protocol.rs

@@ -1,208 +0,0 @@
-use serde_json::{json, Value};
-
-fn send(input: &str) -> Option<Value> {
-    let result = handoff_mcp::mcp::protocol::process_line(input)?;
-    Some(serde_json::from_str(&result).expect("response should be valid JSON"))
-}
-
-#[test]
-fn initialize_returns_capabilities() {
-    let resp = send(
-        r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"0.1.0"}}}"#,
-    )
-    .expect("initialize should return a response");
-
-    assert_eq!(resp["jsonrpc"], "2.0");
-    assert_eq!(resp["id"], 1);
-    assert!(resp["error"].is_null());
-
-    let result = &resp["result"];
-    assert_eq!(result["protocolVersion"], "2025-03-26");
-    assert!(result["capabilities"]["tools"].is_object());
-    assert!(result["capabilities"]["resources"].is_object());
-    assert_eq!(result["serverInfo"]["name"], "handoff-mcp");
-    assert!(result["serverInfo"]["version"].is_string());
-    assert!(result["instructions"].is_string());
-}
-
-#[test]
-fn initialized_notification_returns_nothing() {
-    let resp = send(r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#);
-    assert!(
-        resp.is_none(),
-        "notifications should not produce a response"
-    );
-}
-
-#[test]
-fn tools_list_returns_all_tools() {
-    let resp = send(r#"{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}"#)
-        .expect("tools/list should return a response");
-
-    assert_eq!(resp["id"], 2);
-    assert!(resp["error"].is_null());
-
-    let tools = resp["result"]["tools"]
-        .as_array()
-        .expect("tools should be an array");
-
-    let expected_names = [
-        "handoff_init",
-        "handoff_load_context",
-        "handoff_save_context",
-        "handoff_list_tasks",
-        "handoff_update_task",
-        "handoff_get_config",
-        "handoff_update_config",
-        "handoff_dashboard",
-        "handoff_import_context",
-        "handoff_refer",
-        "handoff_list_referrals",
-        "handoff_update_referral",
-    ];
-
-    let tool_names: Vec<&str> = tools
-        .iter()
-        .map(|t| t["name"].as_str().expect("tool name should be a string"))
-        .collect();
-
-    for expected in &expected_names {
-        assert!(tool_names.contains(expected), "missing tool: {expected}");
-    }
-
-    for tool in tools {
-        assert!(
-            tool["description"].is_string(),
-            "tool should have description"
-        );
-        assert!(
-            tool["inputSchema"].is_object(),
-            "tool should have inputSchema"
-        );
-    }
-}
-
-#[test]
-fn resources_list_returns_resources() {
-    let resp = send(r#"{"jsonrpc":"2.0","id":3,"method":"resources/list","params":{}}"#)
-        .expect("resources/list should return a response");
-
-    assert_eq!(resp["id"], 3);
-    assert!(resp["error"].is_null());
-
-    let resources = resp["result"]["resources"]
-        .as_array()
-        .expect("resources should be an array");
-
-    assert_eq!(resources.len(), 2);
-
-    let uris: Vec<&str> = resources
-        .iter()
-        .map(|r| r["uri"].as_str().expect("resource uri"))
-        .collect();
-
-    assert!(uris.contains(&"handoff://sessions"));
-    assert!(uris.contains(&"handoff://config"));
-}
-
-#[test]
-fn invalid_json_returns_parse_error() {
-    let resp = send("not valid json at all").expect("should return error response");
-
-    assert_eq!(resp["jsonrpc"], "2.0");
-    assert!(resp["id"].is_null());
-
-    let error = &resp["error"];
-    assert_eq!(error["code"], -32700);
-    assert!(error["message"].as_str().unwrap().contains("Parse error"));
-}
-
-#[test]
-fn unknown_method_returns_method_not_found() {
-    let resp = send(r#"{"jsonrpc":"2.0","id":99,"method":"nonexistent/method","params":{}}"#)
-        .expect("should return error response");
-
-    assert_eq!(resp["id"], 99);
-
-    let error = &resp["error"];
-    assert_eq!(error["code"], -32601);
-    assert!(error["message"]
-        .as_str()
-        .unwrap()
-        .contains("Method not found"));
-}
-
-#[test]
-fn invalid_jsonrpc_version_returns_error() {
-    let resp = send(r#"{"jsonrpc":"1.0","id":5,"method":"initialize","params":{}}"#)
-        .expect("should return error response");
-
-    assert_eq!(resp["id"], 5);
-    let error = &resp["error"];
-    assert_eq!(error["code"], -32600);
-}
-
-#[test]
-fn empty_line_returns_none() {
-    assert!(send("").is_none());
-    assert!(send("   ").is_none());
-}
-
-#[test]
-fn request_id_is_preserved() {
-    let resp_str = send(r#"{"jsonrpc":"2.0","id":"abc-123","method":"tools/list","params":{}}"#)
-        .expect("should return response");
-    assert_eq!(resp_str["id"], "abc-123");
-
-    let resp_num = send(r#"{"jsonrpc":"2.0","id":42,"method":"tools/list","params":{}}"#)
-        .expect("should return response");
-    assert_eq!(resp_num["id"], 42);
-}
-
-#[test]
-fn tools_have_valid_input_schemas() {
-    let resp = send(r#"{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}"#)
-        .expect("tools/list response");
-
-    let tools = resp["result"]["tools"].as_array().unwrap();
-    for tool in tools {
-        let schema = &tool["inputSchema"];
-        assert_eq!(
-            schema["type"], "object",
-            "inputSchema for {} should have type: object",
-            tool["name"]
-        );
-    }
-}
-
-#[test]
-fn multiple_requests_in_sequence() {
-    let r1 = send(r#"{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}"#).unwrap();
-    assert!(r1["result"].is_object());
-
-    send(r#"{"jsonrpc":"2.0","method":"notifications/initialized"}"#);
-
-    let r2 = send(r#"{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}"#).unwrap();
-    assert!(r2["result"]["tools"].is_array());
-
-    let r3 = send(r#"{"jsonrpc":"2.0","id":3,"method":"resources/list","params":{}}"#).unwrap();
-    assert!(r3["result"]["resources"].is_array());
-}
-
-#[test]
-fn e2e_json_roundtrip() {
-    let input = json!({
-        "jsonrpc": "2.0",
-        "id": 1,
-        "method": "initialize",
-        "params": {
-            "protocolVersion": "2025-03-26",
-            "capabilities": {},
-            "clientInfo": { "name": "test-client", "version": "1.0" }
-        }
-    });
-
-    let resp = send(&input.to_string()).unwrap();
-    assert_eq!(resp["result"]["protocolVersion"], "2025-03-26");
-    assert_eq!(resp["result"]["serverInfo"]["name"], "handoff-mcp");
-}

package/tests/storage_config.rs

@@ -1,107 +0,0 @@
-use handoff_mcp::storage::config::{read_config, write_config, Config};
-use std::fs;
-use tempfile::TempDir;
-
-fn setup() -> TempDir {
-    tempfile::tempdir().expect("failed to create temp dir")
-}
-
-#[test]
-fn write_and_read_config() {
-    let dir = setup();
-    let path = dir.path().join("config.toml");
-
-    let config = Config::new("test-project", "A test project");
-    write_config(&path, &config).unwrap();
-
-    let read_back = read_config(&path).unwrap();
-    assert_eq!(read_back.project.name, "test-project");
-    assert_eq!(
-        read_back.project.description.as_deref(),
-        Some("A test project")
-    );
-}
-
-#[test]
-fn config_has_correct_defaults() {
-    let dir = setup();
-    let path = dir.path().join("config.toml");
-
-    let config = Config::new("proj", "");
-    write_config(&path, &config).unwrap();
-
-    let read_back = read_config(&path).unwrap();
-    assert_eq!(read_back.settings.history_limit, 20);
-    assert_eq!(read_back.settings.done_task_limit, 10);
-    assert!(read_back.settings.auto_git_summary);
-    assert!(read_back.settings.context_files.is_empty());
-    assert_eq!(read_back.dashboard.scan_dirs, vec!["~/pro/"]);
-    assert!(read_back.dashboard.exclude_patterns.is_empty());
-    assert!(read_back.project.description.is_none());
-}
-
-#[test]
-fn config_with_custom_values() {
-    let dir = setup();
-    let path = dir.path().join("config.toml");
-
-    let toml_content = r#"
-[project]
-name = "custom-proj"
-description = "Custom"
-
-[settings]
-history_limit = 50
-done_task_limit = 5
-auto_git_summary = false
-context_files = ["README.md", "CLAUDE.md"]
-
-[dashboard]
-scan_dirs = ["~/work/", "~/projects/"]
-exclude_patterns = ["*/target", "*/node_modules"]
-"#;
-    fs::write(&path, toml_content).unwrap();
-
-    let config = read_config(&path).unwrap();
-    assert_eq!(config.project.name, "custom-proj");
-    assert_eq!(config.settings.history_limit, 50);
-    assert_eq!(config.settings.done_task_limit, 5);
-    assert!(!config.settings.auto_git_summary);
-    assert_eq!(config.settings.context_files.len(), 2);
-    assert_eq!(config.dashboard.scan_dirs.len(), 2);
-    assert_eq!(config.dashboard.exclude_patterns.len(), 2);
-}
-
-#[test]
-fn config_missing_file_returns_error() {
-    let dir = setup();
-    let path = dir.path().join("nonexistent.toml");
-    assert!(read_config(&path).is_err());
-}
-
-#[test]
-fn config_invalid_toml_returns_error() {
-    let dir = setup();
-    let path = dir.path().join("bad.toml");
-    fs::write(&path, "this is not valid toml [[[").unwrap();
-    assert!(read_config(&path).is_err());
-}
-
-#[test]
-fn config_partial_toml_uses_defaults() {
-    let dir = setup();
-    let path = dir.path().join("config.toml");
-    fs::write(
-        &path,
-        r#"
-[project]
-name = "minimal"
-"#,
-    )
-    .unwrap();
-
-    let config = read_config(&path).unwrap();
-    assert_eq!(config.project.name, "minimal");
-    assert_eq!(config.settings.history_limit, 20);
-    assert_eq!(config.dashboard.scan_dirs, vec!["~/pro/"]);
-}