fix: Auto-discover SerenDB project from target URL (fixes #54)

- Add find_project_by_hostname function to ConsoleClient
- Sync command now discovers project_id by matching target hostname
- Prompt for API key interactively if not provided via env/CLI
- Verify wal_level=logical after enabling via SerenDB API
- Poll for up to 60 seconds with helpful timeout instructions

Author: taariq

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [6.0.7] - 2025-12-08
+
+### Fixed
+
+- **Auto-discover SerenDB project from target URL**: Fixed bug where `sync` command couldn't auto-enable logical replication when using explicit `--target` SerenDB URL without saved state. The tool now discovers the project by matching the target hostname against SerenDB project connection strings. Also prompts for API key interactively if not provided. (Fixes #54)
+
+- **Verify wal_level after enabling logical replication**: After enabling logical replication via SerenDB API, the tool now polls the database to verify `wal_level=logical` is actually applied (up to 60 seconds), with helpful instructions if the endpoint needs manual restart.
+
 ## [6.0.6] - 2025-12-08
 
 ### Fixed

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "database-replicator"
-version = "6.0.6"
+version = "6.0.7"
 edition = "2021"
 license = "Apache-2.0"
 description = "Universal database-to-PostgreSQL replication CLI. Supports PostgreSQL, SQLite, MongoDB, and MySQL."

Cargo.toml

@@ -462,18 +462,72 @@ async fn main() -> anyhow::Result<()> {
                 filter.with_table_rules(table_rule_data)
             };
 
-            // Get project_id from CLI or saved target state
-            let effective_project_id = project_id.or_else(|| {
+            // Get project_id from CLI, saved target state, or discover from target URL
+            let mut effective_project_id = project_id.or_else(|| {
                 database_replicator::serendb::load_target_state()
                     .ok()
                     .flatten()
                     .map(|state| state.project_id)
             });
 
+            // If project_id is still None and target is SerenDB, try to discover it by hostname
+            if effective_project_id.is_none()
+                && database_replicator::utils::is_serendb_target(&resolved_target)
+            {
+                // Get API key from CLI/env, or prompt user interactively
+                let api_key = global_api_key
+                    .clone()
+                    .or_else(|| database_replicator::interactive::get_api_key().ok());
+
+                if let Some(api_key) = api_key {
+                    // Extract hostname from target URL
+                    if let Ok(parts) =
+                        database_replicator::utils::parse_postgres_url(&resolved_target)
+                    {
+                        tracing::info!(
+                            "Discovering SerenDB project for hostname {}...",
+                            parts.host
+                        );
+                        let client = database_replicator::serendb::ConsoleClient::new(
+                            Some(&console_api),
+                            api_key,
+                        );
+                        match client.find_project_by_hostname(&parts.host).await {
+                            Ok(Some(project_id)) => {
+                                effective_project_id = Some(project_id);
+                            }
+                            Ok(None) => {
+                                tracing::warn!(
+                                    "Could not find SerenDB project matching hostname {}. \
+                                     Logical replication auto-enable will be skipped.",
+                                    parts.host
+                                );
+                            }
+                            Err(e) => {
+                                tracing::warn!(
+                                    "Failed to discover project from hostname: {}. \
+                                     Logical replication auto-enable will be skipped.",
+                                    e
+                                );
+                            }
+                        }
+                    }
+                } else {
+                    tracing::debug!(
+                        "No API key available, skipping project discovery from target hostname"
+                    );
+                }
+            }
+
             // If project_id is available and target is SerenDB, check/enable logical replication
             if let Some(ref project_id) = effective_project_id {
                 if database_replicator::utils::is_serendb_target(&resolved_target) {
-                    check_and_enable_logical_replication(project_id, &console_api).await?;
+                    check_and_enable_logical_replication(
+                        project_id,
+                        &console_api,
+                        &resolved_target,
+                    )
+                    .await?;
                 }
             }
 
@@ -536,6 +590,7 @@ async fn main() -> anyhow::Result<()> {
 async fn check_and_enable_logical_replication(
     project_id: &str,
     console_api: &str,
+    target_url: &str,
 ) -> anyhow::Result<()> {
     use database_replicator::serendb::ConsoleClient;
     use dialoguer::{theme::ColorfulTheme, Confirm};
@@ -556,6 +611,29 @@ async fn check_and_enable_logical_replication(
             "✓ Logical replication is already enabled for project '{}'",
             project.name
         );
+        // Verify the actual wal_level on the database (endpoint may still be restarting)
+        match database_replicator::postgres::connect_with_retry(target_url).await {
+            Ok(client) => {
+                if let Ok(row) = client.query_one("SHOW wal_level", &[]).await {
+                    let level: String = row.get(0);
+                    if level == "logical" {
+                        return Ok(());
+                    }
+                    // wal_level not yet 'logical', need to wait for endpoint restart
+                    tracing::info!(
+                        "Endpoint has wal_level='{}', waiting for restart to apply 'logical'...",
+                        level
+                    );
+                }
+            }
+            Err(_) => {
+                tracing::info!("Endpoint may be restarting, will poll for readiness...");
+            }
+        }
+        // Fall through to wait for wal_level to become 'logical'
+        println!();
+        println!("⏳ Waiting for endpoint to restart with wal_level=logical...");
+        wait_for_wal_level_logical(target_url).await?;
         return Ok(());
     }
 
@@ -601,12 +679,9 @@ async fn check_and_enable_logical_replication(
         println!();
         println!("✓ Logical replication enabled successfully!");
         println!();
-        println!("⏳ Waiting for endpoints to restart (this may take up to 30 seconds)...");
+        println!("⏳ Waiting for endpoint to restart with wal_level=logical...");
 
-        // Wait for endpoints to restart - the wal_level change requires endpoint restart
-        tokio::time::sleep(tokio::time::Duration::from_secs(15)).await;
-
-        tracing::info!("✓ Endpoints should now be ready with wal_level=logical");
+        wait_for_wal_level_logical(target_url).await?;
     } else {
         anyhow::bail!(
             "Failed to enable logical replication. The API call succeeded but the setting was not updated.\n\
@@ -619,6 +694,69 @@ async fn check_and_enable_logical_replication(
     Ok(())
 }
 
+/// Poll the database until wal_level becomes 'logical' (up to 60 seconds)
+async fn wait_for_wal_level_logical(target_url: &str) -> anyhow::Result<()> {
+    let max_attempts = 12;
+    let poll_interval = tokio::time::Duration::from_secs(5);
+
+    for attempt in 1..=max_attempts {
+        tokio::time::sleep(poll_interval).await;
+
+        match database_replicator::postgres::connect_with_retry(target_url).await {
+            Ok(client) => {
+                match client
+                    .query_one("SHOW wal_level", &[])
+                    .await
+                    .map(|row| row.get::<_, String>(0))
+                {
+                    Ok(level) if level == "logical" => {
+                        println!();
+                        tracing::info!("✓ Endpoint is ready with wal_level=logical");
+                        return Ok(());
+                    }
+                    Ok(level) => {
+                        print!(
+                            "\r⏳ Attempt {}/{}: wal_level={}, waiting...",
+                            attempt, max_attempts, level
+                        );
+                        std::io::Write::flush(&mut std::io::stdout()).ok();
+                    }
+                    Err(_) => {
+                        print!(
+                            "\r⏳ Attempt {}/{}: checking wal_level...",
+                            attempt, max_attempts
+                        );
+                        std::io::Write::flush(&mut std::io::stdout()).ok();
+                    }
+                }
+            }
+            Err(_) => {
+                print!(
+                    "\r⏳ Attempt {}/{}: endpoint restarting...",
+                    attempt, max_attempts
+                );
+                std::io::Write::flush(&mut std::io::stdout()).ok();
+            }
+        }
+    }
+
+    println!();
+    println!();
+    println!("⚠️  Timed out waiting for wal_level to become 'logical'.");
+    println!();
+    println!("The SerenDB endpoint may need to be manually restarted:");
+    println!("  1. Go to https://console.serendb.com");
+    println!("  2. Navigate to your project's Compute endpoints");
+    println!("  3. Click 'Restart' on the endpoint");
+    println!("  4. Wait for the endpoint to become available");
+    println!("  5. Re-run this command");
+    println!();
+    anyhow::bail!(
+        "Endpoint wal_level is still 'replica' after enabling logical replication. \
+         The endpoint may need to be manually restarted via the SerenDB console."
+    )
+}
+
 #[allow(clippy::too_many_arguments)]
 async fn init_remote(
     source: String,

src/main.rs

@@ -429,6 +429,58 @@ impl ConsoleClient {
         Ok(project.enable_logical_replication)
     }
 
+    /// Find a project by matching the target hostname against project connection strings
+    ///
+    /// This is useful when the user provides a direct connection string (e.g., from
+    /// `init` output) but doesn't have saved target state with the project_id.
+    ///
+    /// # Arguments
+    ///
+    /// * `target_hostname` - The hostname to search for (e.g., "ep-xyz.serendb.com")
+    ///
+    /// # Returns
+    ///
+    /// The project_id if a matching project is found, None otherwise
+    pub async fn find_project_by_hostname(&self, target_hostname: &str) -> Result<Option<String>> {
+        let target_host_lower = target_hostname.to_lowercase();
+
+        // List all projects accessible to this API key
+        let projects = self.list_projects().await?;
+
+        for project in projects {
+            // Get the default branch for each project
+            let branch = match self.get_default_branch(&project.id).await {
+                Ok(b) => b,
+                Err(_) => continue, // Skip projects without branches
+            };
+
+            // Get connection string for this branch (use serendb as dummy database)
+            let conn_str = match self
+                .get_connection_string(&project.id, &branch.id, "serendb", false)
+                .await
+            {
+                Ok(s) => s,
+                Err(_) => continue, // Skip branches without endpoints
+            };
+
+            // Extract hostname from the connection string
+            if let Ok(parts) = crate::utils::parse_postgres_url(&conn_str) {
+                if parts.host.to_lowercase() == target_host_lower {
+                    tracing::info!(
+                        "Found matching project '{}' ({}) for hostname {}",
+                        project.name,
+                        project.id,
+                        target_hostname
+                    );
+                    return Ok(Some(project.id));
+                }
+            }
+        }
+
+        tracing::debug!("No project found matching hostname {}", target_hostname);
+        Ok(None)
+    }
+
     async fn handle_common_errors(&self, response: &reqwest::Response) -> Result<()> {
         self.handle_common_errors_with_context(response, None).await
     }