Fix symlink handling in FUSE and overlay filesystem

The FUSE handlers were using stat() which follows symlinks, causing
symlinks to directories to be incorrectly reported as directories.
This broke operations like `rm -rf` on pnpm's node_modules which uses
symlinks extensively.

Changes:
- Use lstat() instead of stat() in FUSE lookup(), getattr(), unlink(),
  and rmdir() to correctly identify symlinks
- Add EISDIR check in unlink() to reject directory removal attempts
- Fix overlay remove() to detect symlinks and skip directory-empty
  checks for them
- Use lstat() in overlay when checking base layer existence
- Add test for symlink handling

Fixes the "Is a directory" error when removing symlinks to directories.

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

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

Author: penberg

cli/src/fuse.rs

@@ -82,7 +82,7 @@ impl Filesystem for AgentFSFuse {
         };
         let fs = self.fs.clone();
         let (result, path) = self.runtime.block_on(async move {
-            let result = fs.stat(&path).await;
+            let result = fs.lstat(&path).await;
             (result, path)
         });
         match result {
@@ -107,7 +107,7 @@ impl Filesystem for AgentFSFuse {
         };
 
         let fs = self.fs.clone();
-        let result = self.runtime.block_on(async move { fs.stat(&path).await });
+        let result = self.runtime.block_on(async move { fs.lstat(&path).await });
 
         match result {
             Ok(Some(stats)) => reply.attr(&TTL, &fillattr(&stats, self.uid, self.gid)),
@@ -486,10 +486,10 @@ impl Filesystem for AgentFSFuse {
             return;
         };
 
-        // Verify target is a directory
+        // Verify target is a directory (use lstat to not follow symlinks)
         let fs = self.fs.clone();
         let (stat_result, path) = self.runtime.block_on(async move {
-            let result = fs.stat(&path).await;
+            let result = fs.lstat(&path).await;
             (result, path)
         });
 
@@ -505,6 +505,7 @@ impl Filesystem for AgentFSFuse {
             }
         };
 
+        // rmdir() only works on directories, not symlinks or files
         if !stats.is_directory() {
             reply.error(libc::ENOTDIR);
             return;
@@ -617,23 +618,39 @@ impl Filesystem for AgentFSFuse {
             return;
         };
 
-        // Get inode before removing so we can uncache
+        // Get inode before removing so we can uncache (use lstat to not follow symlinks)
         let fs = self.fs.clone();
         let (stat_result, path) = self.runtime.block_on(async move {
-            let result = fs.stat(&path).await;
+            let result = fs.lstat(&path).await;
             (result, path)
         });
 
-        let ino = stat_result.ok().flatten().map(|s| s.ino as u64);
+        let stats = match &stat_result {
+            Ok(Some(s)) => s,
+            Ok(None) => {
+                reply.error(libc::ENOENT);
+                return;
+            }
+            Err(_) => {
+                reply.error(libc::EIO);
+                return;
+            }
+        };
+
+        // unlink() cannot remove directories - use rmdir() for that
+        if stats.is_directory() {
+            reply.error(libc::EISDIR);
+            return;
+        }
+
+        let ino = stats.ino as u64;
 
         let fs = self.fs.clone();
         let result = self.runtime.block_on(async move { fs.remove(&path).await });
 
         match result {
             Ok(()) => {
-                if let Some(ino) = ino {
-                    self.drop_path(ino);
-                }
+                self.drop_path(ino);
                 reply.ok();
             }
             Err(_) => reply.error(libc::EIO),

cli/tests/all.sh

@@ -6,3 +6,4 @@ DIR="$(dirname "$0")"
 "$DIR/test-syscalls.sh"
 "$DIR/test-run-bash.sh"
 "$DIR/test-mount.sh"
+"$DIR/test-symlinks.sh"

cli/tests/test-symlinks.sh

@@ -0,0 +1,64 @@
+#!/bin/sh
+set -e
+
+echo -n "TEST symlink handling... "
+
+# Create a test directory structure with symlinks
+TEST_DIR=$(mktemp -d)
+mkdir -p "$TEST_DIR/target_dir"
+echo "test content" > "$TEST_DIR/target_dir/file.txt"
+ln -s target_dir "$TEST_DIR/link_to_dir"
+ln -s target_dir/file.txt "$TEST_DIR/link_to_file"
+
+cd "$TEST_DIR"
+
+DIR="$(dirname "$0")"
+AGENTFS="cargo run --manifest-path $DIR/../Cargo.toml --"
+
+# Test 1: Verify symlinks are reported as symlinks (not directories/files)
+# ls -la output starts with file type: 'l' for symlink, 'd' for directory
+output=$($AGENTFS run /bin/bash -c 'ls -la link_to_dir' 2>&1 || true)
+
+# The output should contain a line starting with 'l' for the symlink
+if ! echo "$output" | grep -E "^l.* link_to_dir"; then
+    echo "FAILED: symlink to directory not reported as symlink"
+    echo "$output"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+
+# Test 2: Verify symlink to file is reported as symlink
+output=$($AGENTFS run /bin/bash -c 'ls -la link_to_file' 2>&1 || true)
+
+if ! echo "$output" | grep -E "^l.* link_to_file"; then
+    echo "FAILED: symlink to file not reported as symlink"
+    echo "$output"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+
+# Test 3: Verify rm can remove symlink to directory (this was the original bug)
+# Previously this would fail with "Is a directory" because symlinks were misidentified
+output=$($AGENTFS run /bin/bash -c 'rm link_to_dir && echo "symlink removed successfully"' 2>&1 || true)
+
+if ! echo "$output" | grep -q "symlink removed successfully"; then
+    echo "FAILED: could not remove symlink to directory"
+    echo "$output"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+
+# Test 4: Verify the target directory still exists (we removed the symlink, not the target)
+output=$($AGENTFS run /bin/bash -c 'cat target_dir/file.txt' 2>&1 || true)
+
+if ! echo "$output" | grep -q "test content"; then
+    echo "FAILED: target directory should still exist after removing symlink"
+    echo "$output"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+
+# Cleanup
+rm -rf "$TEST_DIR"
+
+echo "OK"

sdk/rust/src/filesystem/overlayfs.rs

@@ -543,31 +543,41 @@ impl FileSystem for OverlayFS {
     async fn remove(&self, path: &str) -> Result<()> {
         let normalized = self.normalize_path(path);
 
-        // Check if directory has children in delta - if so, can't remove
-        if let Some(children) = self.delta.readdir(&normalized).await? {
-            if !children.is_empty() {
-                return Err(FsError::NotEmpty.into());
-            }
-        }
+        // Check if path is a symlink - symlinks don't have children, so skip directory checks
+        let is_symlink = if let Some(stats) = self.lstat(&normalized).await? {
+            stats.is_symlink()
+        } else {
+            false
+        };
 
-        // Check for visible children in base (not whiteout-ed)
-        if let Some(base_children) = self.base.readdir(&normalized).await? {
-            for child in base_children {
-                let child_path = format!("{}/{}", normalized, child);
-                if !self.is_whiteout(&child_path).await? {
+        // Only check for children if not a symlink (directories need to be empty)
+        if !is_symlink {
+            // Check if directory has children in delta - if so, can't remove
+            if let Some(children) = self.delta.readdir(&normalized).await? {
+                if !children.is_empty() {
                     return Err(FsError::NotEmpty.into());
                 }
             }
+
+            // Check for visible children in base (not whiteout-ed)
+            if let Some(base_children) = self.base.readdir(&normalized).await? {
+                for child in base_children {
+                    let child_path = format!("{}/{}", normalized, child);
+                    if !self.is_whiteout(&child_path).await? {
+                        return Err(FsError::NotEmpty.into());
+                    }
+                }
+            }
         }
 
         // Try to remove from delta
         let removed_from_delta = self.delta.remove(&normalized).await.is_ok();
 
-        // Check if it exists in base (and not already whiteout)
+        // Check if it exists in base (and not already whiteout) - use lstat to not follow symlinks
         let exists_in_base = if self.is_whiteout(&normalized).await? {
             false
         } else {
-            self.base.stat(&normalized).await?.is_some()
+            self.base.lstat(&normalized).await?.is_some()
         };
 
         // If exists in base, create whiteout