make it work with remote repos

1. lfs/config.rs — Added resolve_remote()

  - New async method that parses remote_url → RemoteRepository via
  api::client::repositories::get_by_url()
  - Returns Ok(None) when no remote is configured, errors if URL is set but repo doesn't
   exist

  2. api/client/versions.rs — Generic download_versions_to_store()

  - Extracted the HTTP QUERY + gzip + tar extraction logic into
  try_download_versions_to_store() that takes &dyn VersionStore
  - Added public download_versions_to_store() with retry wrapper (same retry logic as
  original)
  - Refactored try_download_data_from_version_paths to delegate — zero behavior change
  for existing callers

  3. lfs/sync.rs — git_add() error handling

  - Changed return type from () to Result<(), OxenError>
  - Propagates spawn errors, logs non-zero exit as warning (non-fatal)
  - Updated both call sites to use ?

  4. lfs/sync.rs — Real push_to_remote() implementation

  - Loads LfsConfig, resolves remote — skips if no remote configured
  - Builds a temp staging dir with files hard-linked/copied from version store at their
  real repo-relative paths
  - Creates workspace → add_files → commit via workspace API
  - On error, attempts workspace cleanup via delete
  - Renamed _args → hook_args and logs for debugging

  5. lfs/sync.rs — Real pull_from_remote() with remote download

  - After local + origin resolution, collects still-missing OIDs into need_remote
  - If !local_only and remote is configured, batch-downloads via
  download_versions_to_store()
  - Restores downloaded files to working tree and runs git_add()

  6. lfs/sync.rs — fetch_all() updated for remote

  - After local+origin resolution, tries configured Oxen remote for unresolved pointers
  - Only errors if pointers remain unresolved AND no remote is available

  7. lfs/filter.rs — Remote fetch in smudge() with 30s timeout

  - Renamed _lfs_config → lfs_config
  - After local + origin checks, attempts remote fetch wrapped in
  tokio::time::timeout(30s)
  - On success, reads from local store; on timeout/error, falls through to pointer
  fallback

  8. lfs/filter_process.rs — Documented _caps

  - Added comment explaining why capabilities are read but unused

  9. Tests (4 new, all passing)

  - test_push_no_remote_configured — succeeds silently with no remote
  - test_pull_local_only_no_network — restores local content, doesn't attempt network
  - test_git_add_returns_result — propagates errors properly
  - test_smudge_remote_fallback_on_no_server — falls back gracefully when remote
  unreachable

  Verification

  - cargo clippy --no-deps -- -D warnings — clean
  - cargo test --lib lfs — 44 tests passed, 0 failed

Author: malcolmgreaves

oxen-rust/src/lib/src/api/client/versions.rs

@@ -5,6 +5,7 @@ use crate::constants::{max_retries, AVG_CHUNK_SIZE};
 use crate::error::OxenError;
 use crate::model::entry::commit_entry::Entry;
 use crate::model::{LocalRepository, MerkleHash, RemoteRepository};
+use crate::storage::version_store::VersionStore;
 use crate::util::{self, concurrency, hasher};
 use crate::view::versions::{
     CleanCorruptedVersionsResponse, CompleteVersionUploadRequest, CompletedFileUpload,
@@ -226,15 +227,56 @@ pub async fn try_download_data_from_version_paths(
     remote_repo: &RemoteRepository,
     hashes: &[String],
     local_repo: &LocalRepository,
+) -> Result<u64, OxenError> {
+    let version_store = local_repo.version_store()?;
+    try_download_versions_to_store(remote_repo, hashes, version_store.as_ref()).await
+}
+
+/// Generic batch download of version blobs into any [`VersionStore`].
+///
+/// Sends the requested hashes to the server, receives a gzip+tar archive,
+/// and streams each entry into `version_store` via `store_version_from_reader`.
+pub async fn download_versions_to_store(
+    remote_repo: &RemoteRepository,
+    hashes: &[String],
+    version_store: &dyn VersionStore,
+) -> Result<u64, OxenError> {
+    let total_retries = max_retries().try_into().unwrap_or(max_retries() as u64);
+    let mut num_retries = 0;
+
+    while num_retries < total_retries {
+        match try_download_versions_to_store(remote_repo, hashes, version_store).await {
+            Ok(val) => return Ok(val),
+            Err(OxenError::Authentication(val)) => return Err(OxenError::Authentication(val)),
+            Err(err) => {
+                num_retries += 1;
+                let sleep_time = num_retries * num_retries;
+                log::warn!("Could not download content {err:?} sleeping {sleep_time}");
+                tokio::time::sleep(std::time::Duration::from_secs(sleep_time)).await;
+            }
+        }
+    }
+
+    let err = format!(
+        "Err: Failed to download {} files after {} retries",
+        hashes.len(),
+        total_retries
+    );
+    Err(OxenError::basic_str(err))
+}
+
+async fn try_download_versions_to_store(
+    remote_repo: &RemoteRepository,
+    hashes: &[String],
+    version_store: &dyn VersionStore,
 ) -> Result<u64, OxenError> {
     let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
     for hash in hashes.iter() {
         let line = format!("{hash}\n");
-        // log::debug!("download_data_from_version_paths encoding line: {} path: {:?}", line, path);
         encoder.write_all(line.as_bytes())?;
     }
     let body = encoder.finish()?;
-    log::debug!("download_data_from_version_paths body len: {}", body.len());
+    log::debug!("download_versions_to_store body len: {}", body.len());
 
     let url = api::endpoint::url_from_repo(remote_repo, "/versions")?;
     let client = client::new_for_url(&url)?;
@@ -254,7 +296,6 @@ pub async fn try_download_data_from_version_paths(
         let decoder = GzipDecoder::new(buf_reader);
         let mut archive = Archive::new(decoder);
 
-        let version_store = local_repo.version_store()?;
         let mut size: u64 = 0;
 
         // Iterate over archive entries and stream them to version store
@@ -298,8 +339,7 @@ pub async fn try_download_data_from_version_paths(
 
         Ok(size)
     } else {
-        let err =
-            format!("api::entries::download_data_from_version_paths Err request failed: {url}");
+        let err = format!("api::versions::download_versions_to_store Err request failed: {url}");
         Err(OxenError::basic_str(err))
     }
 }

oxen-rust/src/lib/src/lfs/config.rs

@@ -2,7 +2,9 @@ use std::path::Path;
 
 use serde::{Deserialize, Serialize};
 
+use crate::api;
 use crate::error::OxenError;
+use crate::model::RemoteRepository;
 
 const LFS_CONFIG_FILENAME: &str = "lfs.toml";
 
@@ -25,6 +27,23 @@ impl LfsConfig {
         Ok(config)
     }
 
+    /// Resolve `remote_url` to a [`RemoteRepository`].
+    ///
+    /// Returns `Ok(None)` when no remote is configured. Returns an error if
+    /// the URL is set but the repository cannot be found on the server.
+    pub async fn resolve_remote(&self) -> Result<Option<RemoteRepository>, OxenError> {
+        let url = match &self.remote_url {
+            Some(u) if !u.is_empty() => u,
+            _ => return Ok(None),
+        };
+        match api::client::repositories::get_by_url(url).await? {
+            Some(repo) => Ok(Some(repo)),
+            None => Err(OxenError::basic_str(format!(
+                "oxen lfs: remote repository not found at {url}"
+            ))),
+        }
+    }
+
     /// Persist to `<oxen_dir>/lfs.toml`.
     pub fn save(&self, oxen_dir: &Path) -> Result<(), OxenError> {
         let path = oxen_dir.join(LFS_CONFIG_FILENAME);

oxen-rust/src/lib/src/lfs/filter.rs

@@ -1,6 +1,8 @@
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::time::Duration;
 
+use crate::api;
 use crate::error::OxenError;
 use crate::lfs::config::LfsConfig;
 use crate::lfs::pointer::PointerFile;
@@ -32,11 +34,12 @@ pub async fn clean(versions_dir: &Path, content: &[u8]) -> Result<Vec<u8>, OxenE
 /// Strategy:
 /// 1. Local `.oxen/versions/` store.
 /// 2. Origin's `.oxen/versions/` (for local clones — discovered via `git config remote.origin.url`).
-/// 3. Fallback: return pointer bytes unchanged with a warning.
+/// 3. Configured Oxen remote (with 30 s timeout).
+/// 4. Fallback: return pointer bytes unchanged with a warning.
 pub async fn smudge(
     versions_dir: &Path,
     repo_root: &Path,
-    _lfs_config: &LfsConfig,
+    lfs_config: &LfsConfig,
     pointer_data: &[u8],
 ) -> Result<Vec<u8>, OxenError> {
     // Not a pointer — return data as-is.
@@ -67,7 +70,35 @@ pub async fn smudge(
         }
     }
 
-    // 3. TODO (Phase 3): fetch from Oxen remote with timeout.
+    // 3. Try the configured Oxen remote with a 30 s timeout.
+    if lfs_config.remote_url.is_some() {
+        match tokio::time::timeout(
+            Duration::from_secs(30),
+            try_fetch_from_remote(lfs_config, &pointer.oid, &store),
+        )
+        .await
+        {
+            Ok(Ok(true)) => {
+                // Successfully downloaded — read from local store.
+                return store.get_version(&pointer.oid).await;
+            }
+            Ok(Ok(false)) => {
+                log::debug!("oxen lfs smudge: remote configured but fetch returned nothing");
+            }
+            Ok(Err(e)) => {
+                log::warn!(
+                    "oxen lfs smudge: remote fetch failed for {}: {e}",
+                    pointer.oid
+                );
+            }
+            Err(_) => {
+                log::warn!(
+                    "oxen lfs smudge: remote fetch timed out for {}",
+                    pointer.oid
+                );
+            }
+        }
+    }
 
     // 4. Fallback — return pointer bytes and warn.
     log::warn!(
@@ -77,6 +108,22 @@ pub async fn smudge(
     Ok(pointer_data.to_vec())
 }
 
+/// Attempt to download a single version from the configured remote.
+/// Returns `Ok(true)` if the hash was successfully stored locally.
+async fn try_fetch_from_remote(
+    lfs_config: &LfsConfig,
+    oid: &str,
+    store: &LocalVersionStore,
+) -> Result<bool, OxenError> {
+    let remote_repo = match lfs_config.resolve_remote().await? {
+        Some(r) => r,
+        None => return Ok(false),
+    };
+    let hashes = vec![oid.to_string()];
+    api::client::versions::download_versions_to_store(&remote_repo, &hashes, store).await?;
+    store.version_exists(oid).await
+}
+
 /// Discover the origin's `.oxen/versions/` directory for local clones.
 ///
 /// Returns `None` if the origin is a remote URL or doesn't have an `.oxen/versions/` dir.
@@ -248,4 +295,25 @@ mod tests {
         let path_str = tmp.path().to_string_lossy().to_string();
         assert_eq!(as_local_path(&path_str), Some(tmp.path().to_path_buf()));
     }
+
+    #[tokio::test]
+    async fn test_smudge_remote_fallback_on_no_server() {
+        // When remote_url is set to an unreachable server, smudge should
+        // fall back gracefully to returning the pointer bytes.
+        let tmp = TempDir::new().unwrap();
+        let repo_root = tmp.path();
+        let versions_dir = tmp.path().join("versions");
+        let config = LfsConfig {
+            remote_url: Some("http://127.0.0.1:19999/nonexistent/repo".to_string()),
+        };
+
+        let ptr = PointerFile::new("deadbeefdeadbeefdeadbeefdeadbeef", 42);
+        let pointer_bytes = ptr.encode();
+
+        let result = smudge(&versions_dir, repo_root, &config, &pointer_bytes)
+            .await
+            .unwrap();
+        // Should fall back to returning the pointer unchanged.
+        assert_eq!(result, pointer_bytes);
+    }
 }

oxen-rust/src/lib/src/lfs/filter_process.rs

@@ -139,7 +139,11 @@ pub fn run_filter_process(versions_dir: &Path) -> Result<(), OxenError> {
     pkt_line::write_flush(&mut writer)?;
     writer.flush()?;
 
-    // Phase 2: Git sends capabilities in one flush group.
+    // Phase 2: Git sends its capabilities (e.g. capability=clean,
+    // capability=smudge) in one flush group. We read and discard them
+    // because the protocol requires consuming this flush group before
+    // we can advertise our own capabilities. We unconditionally
+    // advertise both clean and smudge regardless of what Git offers.
     let _caps = pkt_line::read_text_pairs_until_flush(&mut reader)?;
 
     // Respond with the capabilities we support.