Scope current database per workspace; clear on delete

- `current_database: Option<String>` → `current_databases: HashMap<String, String>` keyed by workspace_id, so switching workspaces no longer inherits a database set in a different workspace.
- `ApiClient::new()` now passes the resolved workspace_id into `load_current_database`, so `X-Database-Id` is only sent when it belongs to the active workspace.
- `print_database_footer()` reads `ACTIVE_WORKSPACE_ID` (set by `resolve_workspace()`) so the footer shows the correct database for the workspace actually used.
- `databases::delete()` clears `current_databases[workspace_id]` when the deleted database was the current one, preventing subsequent commands from silently sending a stale `X-Database-Id`.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: eddietejeda

src/api.rs

@@ -118,7 +118,7 @@ impl ApiClient {
                 }
                 profile_config.sandbox
             }),
-            database_id: crate::config::load_current_database("default"),
+            database_id: workspace_id.and_then(|ws| crate::config::load_current_database("default", ws)),
         }
     }
 

src/config.rs

@@ -101,8 +101,8 @@ pub struct ProfileConfig {
     pub workspaces: Vec<WorkspaceEntry>,
     #[serde(default, skip_serializing_if = "Option::is_none", alias = "session")]
     pub sandbox: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub current_database: Option<String>,
+    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
+    pub current_databases: HashMap<String, String>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -229,7 +229,7 @@ pub fn clear_sandbox(profile: &str) -> Result<(), String> {
     write_config(&config_path, &content)
 }
 
-pub fn save_current_database(profile: &str, database_id: &str) -> Result<(), String> {
+pub fn save_current_database(profile: &str, workspace_id: &str, database_id: &str) -> Result<(), String> {
     let config_path = config_path()?;
 
     let mut config_file: ConfigFile = if config_path.exists() {
@@ -244,21 +244,43 @@ pub fn save_current_database(profile: &str, database_id: &str) -> Result<(), Str
         .profiles
         .entry(profile.to_string())
         .or_default()
-        .current_database = Some(database_id.to_string());
+        .current_databases
+        .insert(workspace_id.to_string(), database_id.to_string());
 
     let content = serde_yaml::to_string(&config_file)
         .map_err(|e| format!("error serializing config: {e}"))?;
     write_config(&config_path, &content)
 }
 
-pub fn load_current_database(profile: &str) -> Option<String> {
+pub fn load_current_database(profile: &str, workspace_id: &str) -> Option<String> {
     let config_path = config_path().ok()?;
     if !config_path.exists() {
         return None;
     }
     let content = fs::read_to_string(&config_path).ok()?;
     let config_file: ConfigFile = serde_yaml::from_str(&content).ok()?;
-    config_file.profiles.get(profile)?.current_database.clone()
+    config_file.profiles.get(profile)?.current_databases.get(workspace_id).cloned()
+}
+
+pub fn clear_current_database(profile: &str, workspace_id: &str) -> Result<(), String> {
+    let config_path = config_path()?;
+
+    if !config_path.exists() {
+        return Ok(());
+    }
+
+    let content = fs::read_to_string(&config_path)
+        .map_err(|e| format!("error reading config file: {e}"))?;
+    let mut config_file: ConfigFile =
+        serde_yaml::from_str(&content).map_err(|e| format!("error parsing config file: {e}"))?;
+
+    if let Some(entry) = config_file.profiles.get_mut(profile) {
+        entry.current_databases.remove(workspace_id);
+    }
+
+    let content = serde_yaml::to_string(&config_file)
+        .map_err(|e| format!("error serializing config: {e}"))?;
+    write_config(&config_path, &content)
 }
 
 pub fn resolve_workspace_id(provided: Option<String>, profile_config: &ProfileConfig) -> Result<String, String> {

src/databases.rs

@@ -436,7 +436,7 @@ pub fn create(
         }
     };
 
-    let _ = crate::config::save_current_database("default", &result.id);
+    let _ = crate::config::save_current_database("default", workspace_id, &result.id);
 
     match format {
         "json" => println!("{}", serde_json::to_string_pretty(&result).unwrap()),
@@ -456,18 +456,18 @@ pub fn set(id_or_description: &str, workspace_id: &str) {
     use crossterm::style::Stylize;
     let api = ApiClient::new(Some(workspace_id));
     let db = resolve_database(&api, id_or_description);
-    if let Err(e) = crate::config::save_current_database("default", &db.id) {
+    if let Err(e) = crate::config::save_current_database("default", workspace_id, &db.id) {
         eprintln!("{}", format!("error saving current database: {e}").red());
         std::process::exit(1);
     }
     println!("{}", format!("Current database set to {}", db.id).green());
 }
 
-fn resolve_current_database(provided: Option<&str>, _workspace_id: &str) -> String {
+fn resolve_current_database(provided: Option<&str>, workspace_id: &str) -> String {
     if let Some(id) = provided {
         return id.to_string();
     }
-    match crate::config::load_current_database("default") {
+    match crate::config::load_current_database("default", workspace_id) {
         Some(id) => id,
         None => {
             use crossterm::style::Stylize;
@@ -492,6 +492,12 @@ pub fn delete(workspace_id: &str, id_or_description: &str) {
         std::process::exit(1);
     }
 
+    // If the deleted database was the current one, clear it so subsequent
+    // commands don't silently send a stale X-Database-Id header.
+    if crate::config::load_current_database("default", workspace_id).as_deref() == Some(&db.id) {
+        let _ = crate::config::clear_current_database("default", workspace_id);
+    }
+
     println!("{}", "Database deleted.".green());
 }
 

src/main.rs

@@ -56,6 +56,10 @@ struct Cli {
     command: Option<Commands>,
 }
 
+/// Set once after workspace resolution so the database footer can reference it
+/// without re-doing config I/O.
+static ACTIVE_WORKSPACE_ID: std::sync::OnceLock<String> = std::sync::OnceLock::new();
+
 fn resolve_workspace(provided: Option<String>) -> String {
     // HOTDATA_WORKSPACE env var takes priority and blocks --workspace-id flag
     if let Ok(ws) = std::env::var("HOTDATA_WORKSPACE") {
@@ -67,6 +71,7 @@ fn resolve_workspace(provided: Option<String>) -> String {
             );
             std::process::exit(1);
         }
+        let _ = ACTIVE_WORKSPACE_ID.set(ws.clone());
         return ws;
     }
     if sandbox::find_sandbox_run_ancestor().is_some() {
@@ -75,7 +80,10 @@ fn resolve_workspace(provided: Option<String>) -> String {
     }
     match config::load("default") {
         Ok(profile) => match config::resolve_workspace_id(provided, &profile) {
-            Ok(id) => id,
+            Ok(id) => {
+                let _ = ACTIVE_WORKSPACE_ID.set(id.clone());
+                id
+            }
             Err(e) => {
                 eprintln!("error: {e}");
                 std::process::exit(1);
@@ -127,12 +135,14 @@ extern "C" fn print_sandbox_footer() {
 
 extern "C" fn print_database_footer() {
     use crossterm::style::Stylize;
-    if let Some(id) = config::load_current_database("default") {
-        eprintln!(
-            "{}",
-            format!("current database: {id}  use 'hotdata databases set' to change")
-                .dark_grey(),
-        );
+    if let Some(ws_id) = ACTIVE_WORKSPACE_ID.get() {
+        if let Some(id) = config::load_current_database("default", ws_id) {
+            eprintln!(
+                "{}",
+                format!("current database: {id}  use 'hotdata databases set' to change")
+                    .dark_grey(),
+            );
+        }
     }
 }