fix(native-sidecar): fix guest wasm file access on js_bridge-backed root mounts (#1646)

Author: NathanFlurry

crates/agentos-actor-plugin/src/persistence.rs

@@ -392,18 +392,24 @@ async fn read_file(host: &HostCtx, path: &str) -> Result<String> {
     if entry.is_directory {
         bail!("EISDIR is a directory: {}", entry.path);
     }
-    // Fetch the content BLOB only here (lookup_entry is metadata-only now).
+    Ok(fetch_content(host, &entry.path).await?.unwrap_or_default())
+}
+
+/// Fetch the content BLOB with a dedicated query. `lookup_entry` is
+/// metadata-only (`NULL AS content`), so every consumer that actually needs
+/// bytes (`read_file`, `pread`, `truncate`, `link`) must fetch them here —
+/// reading `FsEntry::content` off a lookup silently yields empty data.
+async fn fetch_content(host: &HostCtx, path: &str) -> Result<Option<String>> {
     let mut rows = query_rows(
         host,
         "SELECT content FROM agent_os_fs_entries WHERE path = ?",
-        &[json!(entry.path)],
+        &[json!(path)],
     )
     .await?;
-    let content = match rows.first_mut() {
-        Some(row) => optional_content_col(row, "content")?,
-        None => None,
-    };
-    Ok(content.unwrap_or_default())
+    match rows.first_mut() {
+        Some(row) => optional_content_col(row, "content"),
+        None => Ok(None),
+    }
 }
 
 // --- ctx-free helpers (copied verbatim from rivetkit-agent-os::persistence) ---
@@ -846,11 +852,12 @@ async fn link_entry(host: &HostCtx, old_path: String, new_path: String) -> Resul
     if entry.is_directory {
         bail!("EPERM cannot hard-link directory: {old_path}");
     }
+    let content = fetch_content(host, &entry.path).await?;
     insert_entry(
         host,
         &new_path,
         false,
-        entry.content,
+        content,
         entry.mode,
         entry.size,
         entry.symlink_target,
@@ -896,7 +903,8 @@ async fn truncate_file(host: &HostCtx, path: &str, len: i64) -> Result<()> {
     if entry.is_directory {
         bail!("EISDIR is a directory: {}", entry.path);
     }
-    let mut bytes = decode_content(entry.content.as_deref().unwrap_or_default())?;
+    let content = fetch_content(host, &entry.path).await?;
+    let mut bytes = decode_content(content.as_deref().unwrap_or_default())?;
     bytes.resize(len as usize, 0);
     let content = BASE64.encode(bytes);
     run_stmt(
@@ -921,7 +929,8 @@ async fn pread_file(host: &HostCtx, path: &str, offset: i64, len: i64) -> Result
     if entry.is_directory {
         bail!("EISDIR is a directory: {}", entry.path);
     }
-    let bytes = decode_content(entry.content.as_deref().unwrap_or_default())?;
+    let content = fetch_content(host, &entry.path).await?;
+    let bytes = decode_content(content.as_deref().unwrap_or_default())?;
     let start = (offset as usize).min(bytes.len());
     let end = start.saturating_add(len as usize).min(bytes.len());
     Ok(BASE64.encode(&bytes[start..end]))

crates/agentos-actor-plugin/src/persistence_e2e.rs

@@ -390,6 +390,56 @@ async fn persistence_round_trips_fs_ops_against_real_sqlite() {
             "readDir should list hello.txt, got {names:?}"
         );
 
+        // pread must return the real byte range. Regression: pread used to
+        // read `entry.content` off the metadata-only lookup (`NULL AS
+        // content`), so every guest WASM read of a mount-backed root file
+        // came back empty (`cat` printed nothing, `wc -c` reported 0).
+        let pread = persistence::handle_fs_call(
+            &host,
+            "pread",
+            &json!({ "path": path, "offset": 6, "len": 7 }),
+        )
+        .await
+        .expect("pread");
+        assert_eq!(
+            pread,
+            Some(JsonValue::String(BASE64.encode(&content[6..13]))),
+            "pread must return the stored bytes, not the metadata-only view"
+        );
+
+        // Hard link must copy real content (same metadata-only-lookup bug).
+        let link_path = "/work/hello-link.txt";
+        persistence::handle_fs_call(
+            &host,
+            "link",
+            &json!({ "oldPath": path, "newPath": link_path }),
+        )
+        .await
+        .expect("link");
+        let link_read =
+            persistence::handle_fs_call(&host, "readFile", &json!({ "path": link_path }))
+                .await
+                .expect("readFile link");
+        assert_eq!(
+            link_read,
+            Some(JsonValue::String(content_b64.clone())),
+            "hard link must carry the original content"
+        );
+
+        // Truncate must preserve the retained prefix (it used to zero-fill
+        // from the metadata-only empty content).
+        persistence::handle_fs_call(&host, "truncate", &json!({ "path": path, "len": 5 }))
+            .await
+            .expect("truncate");
+        let truncated = persistence::handle_fs_call(&host, "readFile", &json!({ "path": path }))
+            .await
+            .expect("readFile after truncate");
+        assert_eq!(
+            truncated,
+            Some(JsonValue::String(BASE64.encode(&content[..5]))),
+            "truncate must keep the retained bytes intact"
+        );
+
         // removeFile → exists is now false.
         persistence::handle_fs_call(&host, "removeFile", &json!({ "path": path }))
             .await