Add symlink support to FUSE filesystem (#136)

Two issues were preventing symlink creation in agentfs run:

1. The FUSE implementation was missing the symlink() callback, causing
EPERM when tools like npm tried to create symlinks in node_modules/.bin/

2. The OverlayFS ensure_parent_dirs() didn't create parent directories
in the delta layer when they only existed in the base layer. This caused
the delta layer's symlink/write operations to fail with "parent
directory does not exist" since they only look up parents in the delta
database.

Also adds symlink creation tests to test-mount.sh and test-symlinks.sh.

Author: penberg

cli/src/fuse.rs

@@ -655,6 +655,58 @@ impl Filesystem for AgentFSFuse {
         reply.created(&TTL, &attr, 0, fh, 0);
     }
 
+    /// Creates a symbolic link.
+    ///
+    /// Creates a symlink at `name` under `parent` pointing to `link`.
+    fn symlink(
+        &mut self,
+        _req: &Request,
+        parent: u64,
+        link_name: &OsStr,
+        target: &Path,
+        reply: ReplyEntry,
+    ) {
+        let Some(path) = self.lookup_path(parent, link_name) else {
+            reply.error(libc::ENOENT);
+            return;
+        };
+
+        let Some(target_str) = target.to_str() else {
+            reply.error(libc::EINVAL);
+            return;
+        };
+
+        let fs = self.fs.clone();
+        let target_owned = target_str.to_string();
+        let (result, path) = self.runtime.block_on(async move {
+            let result = fs.symlink(&target_owned, &path).await;
+            (result, path)
+        });
+
+        if result.is_err() {
+            reply.error(libc::EIO);
+            return;
+        }
+
+        // Get the new symlink's stats
+        let fs = self.fs.clone();
+        let (stat_result, path) = self.runtime.block_on(async move {
+            let result = fs.lstat(&path).await;
+            (result, path)
+        });
+
+        match stat_result {
+            Ok(Some(stats)) => {
+                let attr = fillattr(&stats, self.uid, self.gid);
+                self.add_path(attr.ino, path);
+                reply.entry(&TTL, &attr, 0);
+            }
+            _ => {
+                reply.error(libc::EIO);
+            }
+        }
+    }
+
     /// Removes a file (unlinks it from the directory).
     ///
     /// Gets the file's inode before removal to clean up the path cache.

cli/tests/test-mount.sh

@@ -80,6 +80,50 @@ if [ "$NESTED_CONTENT" != "nested file" ]; then
     exit 1
 fi
 
+# Test symlink creation
+ln -s nested.txt "$MOUNTPOINT/testdir/link_to_nested"
+if [ ! -L "$MOUNTPOINT/testdir/link_to_nested" ]; then
+    echo "FAILED: symlink was not created"
+    kill $MOUNT_PID 2>/dev/null || true
+    exit 1
+fi
+
+# Test reading symlink target
+LINK_TARGET=$(readlink "$MOUNTPOINT/testdir/link_to_nested")
+if [ "$LINK_TARGET" != "nested.txt" ]; then
+    echo "FAILED: symlink target mismatch"
+    echo "Expected: nested.txt"
+    echo "Got: $LINK_TARGET"
+    kill $MOUNT_PID 2>/dev/null || true
+    exit 1
+fi
+
+# Test following symlink to read file
+LINKED_CONTENT=$(cat "$MOUNTPOINT/testdir/link_to_nested")
+if [ "$LINKED_CONTENT" != "nested file" ]; then
+    echo "FAILED: reading through symlink failed"
+    echo "Expected: nested file"
+    echo "Got: $LINKED_CONTENT"
+    kill $MOUNT_PID 2>/dev/null || true
+    exit 1
+fi
+
+# Test symlink to directory
+ln -s testdir "$MOUNTPOINT/link_to_testdir"
+if [ ! -L "$MOUNTPOINT/link_to_testdir" ]; then
+    echo "FAILED: symlink to directory was not created"
+    kill $MOUNT_PID 2>/dev/null || true
+    exit 1
+fi
+
+# Test accessing file through directory symlink
+DIR_LINKED_CONTENT=$(cat "$MOUNTPOINT/link_to_testdir/nested.txt")
+if [ "$DIR_LINKED_CONTENT" != "nested file" ]; then
+    echo "FAILED: reading through directory symlink failed"
+    kill $MOUNT_PID 2>/dev/null || true
+    exit 1
+fi
+
 # Unmount
 fusermount -u "$MOUNTPOINT"
 

cli/tests/test-symlinks.sh

@@ -49,4 +49,31 @@ if ! cat "$TEST_DIR/target_dir/file.txt" | grep -q "test content"; then
     exit 1
 fi
 
+# Test 5: Create a symlink inside the sandbox (tests FUSE symlink creation)
+output=$(cargo run -- run /bin/bash -c "ln -s target_dir/file.txt $TEST_DIR/new_symlink && readlink $TEST_DIR/new_symlink" 2>&1)
+
+if ! echo "$output" | grep -q "target_dir/file.txt"; then
+    echo "FAILED: could not create symlink in sandbox"
+    echo "$output"
+    exit 1
+fi
+
+# Test 6: Create and follow symlink to read file content
+output=$(cargo run -- run /bin/bash -c "ln -s target_dir $TEST_DIR/new_dir_link && cat $TEST_DIR/new_dir_link/file.txt" 2>&1)
+
+if ! echo "$output" | grep -q "test content"; then
+    echo "FAILED: could not read through newly created symlink"
+    echo "$output"
+    exit 1
+fi
+
+# Test 7: Verify symlinks created in sandbox are visible via ls -l
+output=$(cargo run -- run /bin/bash -c "ln -s foo $TEST_DIR/test_link && ls -la $TEST_DIR/test_link" 2>&1)
+
+if ! echo "$output" | grep -qE "^lrwx.*test_link -> foo"; then
+    echo "FAILED: newly created symlink not shown correctly in ls"
+    echo "$output"
+    exit 1
+fi
+
 echo "OK"

sdk/rust/src/filesystem/overlayfs.rs

@@ -364,7 +364,11 @@ impl OverlayFS {
 
             match stats {
                 Some(s) if s.is_directory() => {
-                    // Already a directory, continue
+                    // Directory exists in base or delta
+                    // Make sure it exists in delta too (required for delta operations)
+                    if self.delta.stat(&current).await?.is_none() {
+                        self.delta.mkdir(&current).await?;
+                    }
                 }
                 Some(_) => {
                     // Exists but not a directory - this is an error