feat: upgrade opendal + add Vercel Artifacts cache backend

Upgrades opendal to mmastrac/opendal vercel_opts branch via
[patch.crates-io], which tracks apache/opendal main plus additional
Vercel Artifacts builder methods (endpoint, team_id, team_slug)
from apache/opendal#7334.

Adds layers-logging feature to retain LoggingLayer after upstream
split. Adds aws-lc-sys with prebuilt-nasm and bindgen features to
avoid nasm/bindgen build requirements in CI cross-compilation.

Adds Vercel Artifacts cache backend configured via:
- SCCACHE_VERCEL_ARTIFACTS_TOKEN (required)
- SCCACHE_VERCEL_ARTIFACTS_ENDPOINT (optional)
- SCCACHE_VERCEL_ARTIFACTS_TEAM_ID (optional)
- SCCACHE_VERCEL_ARTIFACTS_TEAM_SLUG (optional)

Upstream: apache/opendal#7334

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mmastrac

Cargo.lock

@@ -31,6 +31,7 @@ strip = true
 anyhow = { version = "1.0", features = ["backtrace"] }
 ar = "0.9"
 async-trait = "0.1"
+aws-lc-sys = { version = "0.39.1", features = ["prebuilt-nasm"] }
 backon = { version = "1", default-features = false, features = [
   "std-blocking-sleep",
 ] }
@@ -69,7 +70,9 @@ memmap2 = "0.9.4"
 mime = "0.3"
 number_prefix = "0.4"
 object = "0.37"
-opendal = { version = "0.55.0", optional = true, default-features = false }
+opendal = { version = "0.55.0", optional = true, default-features = false, features = [
+  "layers-logging",
+] }
 openssl = { version = "0.10.75", optional = true }
 rand = "0.8.4"
 regex = "1.10.3"
@@ -167,6 +170,7 @@ all = [
   "webdav",
   "oss",
   "cos",
+  "vercel_artifacts",
 ]
 azure = ["opendal/services-azblob", "reqsign", "reqwest"]
 cos = ["opendal/services-cos", "reqsign", "reqwest"]
@@ -178,6 +182,7 @@ native-zlib = []
 oss = ["opendal/services-oss", "reqsign", "reqwest"]
 redis = ["url", "opendal/services-redis"]
 s3 = ["opendal/services-s3", "reqsign", "reqwest"]
+vercel_artifacts = ["opendal/services-vercel-artifacts", "reqwest"]
 webdav = ["opendal/services-webdav", "reqwest"]
 # Enable features that will build a vendored version of openssl and
 # statically linked with it, instead of linking against the system-wide openssl
@@ -233,3 +238,6 @@ ptr_as_ptr = "warn"
 ref_option = "warn"
 semicolon_if_nothing_returned = "warn"
 unnecessary_semicolon = "warn"
+
+[patch.crates-io]
+opendal = { git = "https://github.com/mmastrac/opendal.git", rev = "723ba7f7359e", package = "opendal" }

Cargo.toml

@@ -310,3 +310,10 @@ The full url appears then as `redis://user:passwd@1.2.3.4:6379/?db=1`.
 * `SCCACHE_COS_KEY_PREFIX`
 * `TENCENTCLOUD_SECRET_ID`
 * `TENCENTCLOUD_SECRET_KEY`
+
+#### Vercel Artifacts
+
+* `SCCACHE_VERCEL_ARTIFACTS_TOKEN` Vercel access token for the artifacts API (required)
+* `SCCACHE_VERCEL_ARTIFACTS_ENDPOINT` API endpoint (default: `https://api.vercel.com`)
+* `SCCACHE_VERCEL_ARTIFACTS_TEAM_ID` Vercel team ID, appended as `teamId` query parameter
+* `SCCACHE_VERCEL_ARTIFACTS_TEAM_SLUG` Vercel team slug, appended as `slug` query parameter

docs/Configuration.md

@@ -40,9 +40,12 @@ use crate::cache::s3::S3Cache;
     feature = "s3",
     feature = "webdav",
     feature = "oss",
-    feature = "cos"
+    feature = "cos",
+    feature = "vercel_artifacts"
 ))]
 use crate::cache::utils::normalize_key;
+#[cfg(feature = "vercel_artifacts")]
+use crate::cache::vercel_artifacts::VercelArtifactsCache;
 #[cfg(feature = "webdav")]
 use crate::cache::webdav::WebdavCache;
 use crate::compiler::PreprocessorCacheEntry;
@@ -169,6 +172,9 @@ pub trait Storage: Send + Sync {
 pub struct RemoteStorage {
     operator: opendal::Operator,
     basedirs: Vec<Vec<u8>>,
+    /// When true, use flat keys (no `a/b/c/` prefix). Required for backends
+    /// like Vercel Artifacts where the key must be a plain hex hash.
+    flat_keys: bool,
 }
 
 #[cfg(any(
@@ -184,7 +190,27 @@ pub struct RemoteStorage {
 ))]
 impl RemoteStorage {
     pub fn new(operator: opendal::Operator, basedirs: Vec<Vec<u8>>) -> Self {
-        Self { operator, basedirs }
+        Self {
+            operator,
+            basedirs,
+            flat_keys: false,
+        }
+    }
+
+    pub fn new_flat(operator: opendal::Operator, basedirs: Vec<Vec<u8>>) -> Self {
+        Self {
+            operator,
+            basedirs,
+            flat_keys: true,
+        }
+    }
+
+    fn key_path(&self, key: &str) -> String {
+        if self.flat_keys {
+            key.to_string()
+        } else {
+            normalize_key(key)
+        }
     }
 }
 
@@ -203,7 +229,7 @@ impl RemoteStorage {
 #[async_trait]
 impl Storage for RemoteStorage {
     async fn get(&self, key: &str) -> Result<Cache> {
-        match self.operator.read(&normalize_key(key)).await {
+        match self.operator.read(&self.key_path(key)).await {
             Ok(res) => {
                 let hit = CacheRead::from(io::Cursor::new(res.to_bytes()))?;
                 Ok(Cache::Hit(hit))
@@ -306,7 +332,7 @@ impl Storage for RemoteStorage {
     /// which would corrupt the cache entry when written to another level.
     async fn get_raw(&self, key: &str) -> Result<Option<Vec<u8>>> {
         trace!("opendal::Operator::get_raw({})", key);
-        match self.operator.read(&normalize_key(key)).await {
+        match self.operator.read(&self.key_path(key)).await {
             Ok(res) => {
                 let data = res.to_vec();
                 trace!(
@@ -337,7 +363,7 @@ impl Storage for RemoteStorage {
         trace!("opendal::Operator::put_raw({}, {} bytes)", key, data.len());
         let start = std::time::Instant::now();
 
-        self.operator.write(&normalize_key(key), data).await?;
+        self.operator.write(&self.key_path(key), data).await?;
 
         Ok(start.elapsed())
     }
@@ -542,6 +568,20 @@ pub fn build_single_cache(
             let storage = RemoteStorage::new(operator, basedirs.to_vec());
             Ok(Arc::new(storage))
         }
+        #[cfg(feature = "vercel_artifacts")]
+        CacheType::VercelArtifacts(c) => {
+            debug!("Init vercel artifacts cache");
+
+            let operator = VercelArtifactsCache::build(
+                &c.access_token,
+                c.endpoint.as_deref(),
+                c.team_id.as_deref(),
+                c.team_slug.as_deref(),
+            )
+            .map_err(|err| anyhow!("create vercel artifacts cache failed: {err:?}"))?;
+            let storage = RemoteStorage::new_flat(operator, basedirs.to_vec());
+            Ok(Arc::new(storage))
+        }
         #[allow(unreachable_patterns)]
         _ => {
             bail!("Cache type not supported with current feature configuration")

src/cache/cache.rs

@@ -21,6 +21,21 @@ use opendal::services::Memcached;
 
 use crate::errors::*;
 
+/// Resolve hostname in a memcached endpoint URL to an IP address.
+/// The new opendal memcached service uses SocketAddr::parse internally which
+/// doesn't support DNS hostnames, only IP:port. This works around that by
+/// resolving tcp://hostname:port to tcp://ip:port.
+fn resolve_memcached_endpoint(url: &str) -> String {
+    if let Some(rest) = url.strip_prefix("tcp://") {
+        if let Ok(addrs) = std::net::ToSocketAddrs::to_socket_addrs(&rest) {
+            if let Some(addr) = addrs.into_iter().next() {
+                return format!("tcp://{}", addr);
+            }
+        }
+    }
+    url.to_string()
+}
+
 #[derive(Clone)]
 pub struct MemcachedCache;
 
@@ -32,7 +47,10 @@ impl MemcachedCache {
         key_prefix: &str,
         expiration: u32,
     ) -> Result<Operator> {
-        let mut builder = Memcached::default().endpoint(url);
+        // The new opendal memcached service uses SocketAddr::parse which doesn't
+        // support hostnames. Resolve hostname to IP if the endpoint uses tcp://.
+        let url = resolve_memcached_endpoint(url);
+        let mut builder = Memcached::default().endpoint(&url);
 
         if let Some(username) = username {
             builder = builder.username(username);

src/cache/memcached.rs

@@ -37,6 +37,8 @@ pub mod redis;
 #[cfg(feature = "s3")]
 pub mod s3;
 pub(crate) mod utils;
+#[cfg(feature = "vercel_artifacts")]
+pub mod vercel_artifacts;
 #[cfg(feature = "webdav")]
 pub mod webdav;
 
@@ -47,7 +49,8 @@ pub mod webdav;
     feature = "s3",
     feature = "webdav",
     feature = "oss",
-    feature = "cos"
+    feature = "cos",
+    feature = "vercel_artifacts"
 ))]
 pub(crate) mod http_client;
 

src/cache/mod.rs

@@ -409,7 +409,8 @@ impl MultiLevelStorage {
                     feature = "s3",
                     feature = "webdav",
                     feature = "oss",
-                    feature = "cos"
+                    feature = "cos",
+                    feature = "vercel_artifacts"
                 ))]
                 {
                     let cache_type = match level_name.to_lowercase().as_str() {
@@ -435,6 +436,12 @@ impl MultiLevelStorage {
                         "oss" => config.cache_configs.oss.clone().map(CacheType::OSS),
                         #[cfg(feature = "cos")]
                         "cos" => config.cache_configs.cos.clone().map(CacheType::COS),
+                        #[cfg(feature = "vercel_artifacts")]
+                        "vercel_artifacts" => config
+                            .cache_configs
+                            .vercel_artifacts
+                            .clone()
+                            .map(CacheType::VercelArtifacts),
                         _ => {
                             return Err(anyhow!("Unknown cache level: '{}'", level_name));
                         }

src/cache/multilevel.rs

@@ -0,0 +1,36 @@
+use opendal::Operator;
+use opendal::layers::{HttpClientLayer, LoggingLayer};
+use opendal::services::VercelArtifacts;
+
+use crate::errors::*;
+
+use super::http_client::set_user_agent;
+
+/// A cache that stores entries in Vercel Artifacts.
+pub struct VercelArtifactsCache;
+
+impl VercelArtifactsCache {
+    pub fn build(
+        access_token: &str,
+        endpoint: Option<&str>,
+        team_id: Option<&str>,
+        team_slug: Option<&str>,
+    ) -> Result<Operator> {
+        let mut builder = VercelArtifacts::default().access_token(access_token);
+        if let Some(endpoint) = endpoint {
+            builder = builder.endpoint(endpoint);
+        }
+        if let Some(team_id) = team_id {
+            builder = builder.team_id(team_id);
+        }
+        if let Some(team_slug) = team_slug {
+            builder = builder.team_slug(team_slug);
+        }
+
+        let op = Operator::new(builder)?
+            .layer(HttpClientLayer::new(set_user_agent()))
+            .layer(LoggingLayer::default())
+            .finish();
+        Ok(op)
+    }
+}

src/cache/vercel_artifacts.rs

@@ -349,6 +349,15 @@ pub struct GHACacheConfig {
     pub version: String,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct VercelArtifactsCacheConfig {
+    pub access_token: String,
+    pub endpoint: Option<String>,
+    pub team_id: Option<String>,
+    pub team_slug: Option<String>,
+}
+
 /// Memcached's default value of expiration is 10800s (3 hours), which is too
 /// short for use case of sccache.
 ///
@@ -484,6 +493,7 @@ pub enum CacheType {
     Webdav(WebdavCacheConfig),
     OSS(OSSCacheConfig),
     COS(COSCacheConfig),
+    VercelArtifacts(VercelArtifactsCacheConfig),
 }
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
@@ -499,6 +509,7 @@ pub struct CacheConfigs {
     pub webdav: Option<WebdavCacheConfig>,
     pub oss: Option<OSSCacheConfig>,
     pub cos: Option<COSCacheConfig>,
+    pub vercel_artifacts: Option<VercelArtifactsCacheConfig>,
     /// Multi-level cache configuration
     pub multilevel: Option<MultiLevelConfig>,
 }
@@ -518,6 +529,7 @@ impl CacheConfigs {
             webdav,
             oss,
             cos,
+            vercel_artifacts,
             multilevel: _,
         } = self;
 
@@ -530,7 +542,8 @@ impl CacheConfigs {
             .or_else(|| azure.map(CacheType::Azure))
             .or_else(|| webdav.map(CacheType::Webdav))
             .or_else(|| oss.map(CacheType::OSS))
-            .or_else(|| cos.map(CacheType::COS));
+            .or_else(|| cos.map(CacheType::COS))
+            .or_else(|| vercel_artifacts.map(CacheType::VercelArtifacts));
 
         let fallback = disk.unwrap_or_default();
 
@@ -576,6 +589,13 @@ impl CacheConfigs {
                     "oss" => self.oss.clone().map(CacheType::OSS).ok_or_else(|| {
                         anyhow!("OSS cache not configured but specified in levels")
                     })?,
+                    "vercel_artifacts" => self
+                        .vercel_artifacts
+                        .clone()
+                        .map(CacheType::VercelArtifacts)
+                        .ok_or_else(|| {
+                            anyhow!("Vercel Artifacts cache not configured but specified in levels")
+                        })?,
                     "disk" => {
                         // Disk cache is handled separately in MultiLevelStorage::from_config
                         // Mark it by continuing - it will be added to the storage list there
@@ -606,6 +626,7 @@ impl CacheConfigs {
             webdav,
             oss,
             cos,
+            vercel_artifacts,
             multilevel,
         } = other;
 
@@ -639,6 +660,9 @@ impl CacheConfigs {
         if cos.is_some() {
             self.cos = cos;
         }
+        if vercel_artifacts.is_some() {
+            self.vercel_artifacts = vercel_artifacts;
+        }
 
         if multilevel.is_some() {
             self.multilevel = multilevel;
@@ -1092,6 +1116,21 @@ fn config_from_env() -> Result<EnvConfig> {
         None
     };
 
+    // ======= Vercel Artifacts =======
+    let vercel_artifacts = if let Ok(access_token) = env::var("SCCACHE_VERCEL_ARTIFACTS_TOKEN") {
+        let endpoint = env::var("SCCACHE_VERCEL_ARTIFACTS_ENDPOINT").ok();
+        let team_id = env::var("SCCACHE_VERCEL_ARTIFACTS_TEAM_ID").ok();
+        let team_slug = env::var("SCCACHE_VERCEL_ARTIFACTS_TEAM_SLUG").ok();
+        Some(VercelArtifactsCacheConfig {
+            access_token,
+            endpoint,
+            team_id,
+            team_slug,
+        })
+    } else {
+        None
+    };
+
     // ======= Local =======
     let disk_dir = env::var_os("SCCACHE_DIR").map(PathBuf::from);
     let disk_sz = env::var("SCCACHE_CACHE_SIZE")
@@ -1162,6 +1201,7 @@ fn config_from_env() -> Result<EnvConfig> {
         webdav,
         oss,
         cos,
+        vercel_artifacts,
         multilevel,
     };
 
@@ -2362,6 +2402,7 @@ key_prefix = "cosprefix"
                     endpoint: Some("cos.na-siliconvalley.myqcloud.com".to_owned()),
                     key_prefix: "cosprefix".into(),
                 }),
+                vercel_artifacts: None,
                 multilevel: None,
             },
             dist: DistConfig {

src/config.rs

@@ -181,6 +181,7 @@ pub fn sccache_client_cfg(
             webdav: None,
             oss: None,
             cos: None,
+            vercel_artifacts: None,
             multilevel: None,
         },
         dist: sccache::config::DistConfig {