Move is_overlay_enabled() from CLI to SDK

The function checks if an overlay filesystem is configured and returns
the base path. This belongs in the SDK so it can be used by SDK consumers,
not just the CLI.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: penberg

cli/src/cmd/fs.rs

@@ -1,6 +1,6 @@
 use std::collections::{HashSet, VecDeque};
 
-use agentfs_sdk::AgentFSOptions;
+use agentfs_sdk::{AgentFS, AgentFSOptions};
 use anyhow::{Context, Result as AnyhowResult};
 use turso::{Builder, Connection, Value};
 
@@ -210,39 +210,6 @@ impl std::fmt::Display for ChangeType {
     }
 }
 
-/// Check if overlay is enabled for this filesystem
-async fn is_overlay_enabled(conn: &Connection) -> AnyhowResult<Option<String>> {
-    // Check if fs_overlay_config table exists and has base_path
-    let result = conn
-        .query(
-            "SELECT value FROM fs_overlay_config WHERE key = 'base_path'",
-            (),
-        )
-        .await;
-
-    match result {
-        Ok(mut rows) => {
-            if let Some(row) = rows.next().await? {
-                let base_path: String = row
-                    .get_value(0)
-                    .ok()
-                    .and_then(|v| {
-                        if let Value::Text(s) = v {
-                            Some(s.clone())
-                        } else {
-                            None
-                        }
-                    })
-                    .unwrap_or_default();
-                Ok(Some(base_path))
-            } else {
-                Ok(None)
-            }
-        }
-        Err(_) => Ok(None), // Table doesn't exist
-    }
-}
-
 /// Get all paths in the delta layer (files in fs_dentry)
 async fn get_delta_paths(conn: &Connection) -> AnyhowResult<HashSet<String>> {
     let mut paths = HashSet::new();
@@ -403,18 +370,13 @@ fn path_exists_in_base(base_path: &str, rel_path: &str) -> bool {
 
 pub async fn diff_filesystem(id_or_path: String) -> AnyhowResult<()> {
     let options = AgentFSOptions::resolve(&id_or_path)?;
-    let db_path = options.path.context("No database path resolved")?;
     eprintln!("Using agent: {}", id_or_path);
 
-    let db = Builder::new_local(&db_path)
-        .build()
-        .await
-        .context("Failed to open filesystem")?;
-
-    let conn = db.connect().context("Failed to connect to filesystem")?;
+    let agent = AgentFS::open(options).await.context("Failed to open agent")?;
+    let conn = agent.get_connection();
 
     // Check if overlay is enabled
-    let base_path = match is_overlay_enabled(&conn).await? {
+    let base_path = match agent.is_overlay_enabled().await? {
         Some(path) => path,
         None => {
             println!("No diff (non-overlay filesystem)");

sdk/rust/src/lib.rs

@@ -4,7 +4,7 @@ pub mod toolcalls;
 
 use anyhow::Result;
 use std::{path::Path, sync::Arc};
-use turso::{Builder, Connection};
+use turso::{Builder, Connection, Value};
 
 // Re-export filesystem types
 #[cfg(unix)]
@@ -196,6 +196,42 @@ impl AgentFS {
         self.conn.clone()
     }
 
+    /// Check if overlay is enabled for this filesystem
+    ///
+    /// Returns the base path if overlay is enabled, None otherwise.
+    pub async fn is_overlay_enabled(&self) -> Result<Option<String>> {
+        // Check if fs_overlay_config table exists and has base_path
+        let result = self
+            .conn
+            .query(
+                "SELECT value FROM fs_overlay_config WHERE key = 'base_path'",
+                (),
+            )
+            .await;
+
+        match result {
+            Ok(mut rows) => {
+                if let Some(row) = rows.next().await? {
+                    let base_path: String = row
+                        .get_value(0)
+                        .ok()
+                        .and_then(|v| {
+                            if let Value::Text(s) = v {
+                                Some(s.clone())
+                            } else {
+                                None
+                            }
+                        })
+                        .unwrap_or_default();
+                    Ok(Some(base_path))
+                } else {
+                    Ok(None)
+                }
+            }
+            Err(_) => Ok(None), // Table doesn't exist
+        }
+    }
+
     /// Validates an agent ID to prevent path traversal and ensure safe filesystem operations.
     /// Returns true if the ID contains only alphanumeric characters, hyphens, and underscores.
     pub fn validate_agent_id(id: &str) -> bool {