Fix Bun patch compatibility and refusals

Support Bun text lock version 0 and reject workspace layouts whose
tarball paths cannot survive native reinstalls. Refuse incompatible
vendored downloads before recording manifest patch intent.

Add native release/configuration checks for hosted, vendored and
detached installs, patched bytes, integrity and rollback.

Assisted-by: Codex:gpt-6-astra

Author: mikolalysenko

.github/workflows/bun-compatibility.yml

@@ -0,0 +1,87 @@
+name: Bun patch compatibility
+
+on:
+  pull_request:
+    paths:
+      - '.github/workflows/bun-compatibility.yml'
+      - 'scripts/backtest-bun.py'
+      - 'crates/socket-patch-core/src/vendor/**'
+      - 'crates/socket-patch-core/src/patch/redirect/**'
+      - 'crates/socket-patch-cli/src/commands/get.rs'
+      - 'crates/socket-patch-cli/src/commands/scan/**'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: bun-patch-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_PROFILE_DEV_DEBUG: '0'
+  CARGO_INCREMENTAL: '0'
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd
+        with:
+          persist-credentials: false
+      - uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4
+        with:
+          key: bun-native
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+      - run: cargo build --locked -p socket-patch-cli
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        with:
+          name: bun-cli-${{ matrix.os }}
+          path: |
+            target/debug/socket-patch
+            target/debug/socket-patch.exe
+          if-no-files-found: error
+          retention-days: 7
+  native:
+    needs: build
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        bun: ['0.8.1', '1.0.0', '1.0.36', '1.1.0', '1.1.38', '1.1.39', '1.1.45', '1.2.0', '1.2.23', '1.3.0', '1.3.14', '1.4.0', '1.4.2']
+        exclude:
+          - {os: windows-latest, bun: '0.8.1'}
+          - {os: windows-latest, bun: '1.0.0'}
+          - {os: windows-latest, bun: '1.0.36'}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd
+        with:
+          persist-credentials: false
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093
+        with:
+          name: bun-cli-${{ matrix.os }}
+          path: native-cli
+      - name: Install, verify patched bytes, reject corruption, and roll back
+        shell: bash
+        run: |
+          chmod +x native-cli/socket-patch*
+          python scripts/backtest-bun.py --cli "native-cli/socket-patch${{ runner.os == 'Windows' && '.exe' || '' }}" --cli-revision "${{ github.event.pull_request.head.sha || github.sha }}" --output native-bun --versions '${{ matrix.bun }}' --modes hosted vendored vendored-detached --jobs 3
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        if: always()
+        with:
+          name: bun-results-${{ matrix.os }}-${{ matrix.bun }}
+          include-hidden-files: true
+          path: |
+            native-bun/summary.json
+            native-bun/captures/**/result.json
+            native-bun/captures/**/cli-output.json
+            native-bun/captures/**/tree/**
+            native-bun/captures/**/*.log
+          retention-days: 14

crates/socket-patch-cli/src/commands/get.rs

@@ -1512,7 +1512,33 @@ pub async fn download_and_apply_patches(
     let mut patches_downloaded = 0;
     let mut downloaded_patches: Vec<serde_json::Value> = Vec::new();
 
+    // Vendored downloads must not claim a patch in the manifest when Bun
+    // cannot consume its artifact. Agent/save-only flows retain their intent.
+    let bun_refusal = if params.save_only && !params.persist_blobs {
+        socket_patch_core::vendor::bun_lock::preflight_vendor(&params.cwd)
+            .await
+            .err()
+    } else {
+        None
+    };
     for search_result in &selected {
+        if let Some((code, detail)) = bun_refusal
+            .as_ref()
+            .filter(|_| search_result.purl.starts_with("pkg:npm/"))
+        {
+            patches_failed += 1;
+            downloaded_patches.push(serde_json::json!({
+                "purl": search_result.purl,
+                "uuid": search_result.uuid,
+                "action": "failed",
+                "errorCode": code,
+                "error": detail,
+            }));
+            if !params.json && !params.silent {
+                eprintln!("  [error] {}: {detail}", search_result.purl);
+            }
+            continue;
+        }
         // org slug is already stored in the client.
         match api_client.fetch_patch(None, &search_result.uuid).await {
             Ok(Some(patch)) => {

crates/socket-patch-core/src/patch/redirect/mod.rs

@@ -2380,7 +2380,8 @@ fn rewrite_bun_lock(
     result: &mut RewriteResult,
 ) {
     use crate::vendor::bun_lock_text::{
-        check_lock_version, decode_json_string, parse_packages_section,
+        check_lock_version, decode_json_string, has_workspace_packages, lock_version,
+        parse_packages_section,
     };
 
     let npm: Vec<&DepOverride> = overrides.iter().filter(|o| o.ecosystem == "npm").collect();
@@ -2404,7 +2405,7 @@ fn rewrite_bun_lock(
     if check_lock_version(content).is_err() {
         result.warnings.push(RewriteWarning {
             code: "redirect_bun_lock_unsupported".into(),
-            detail: "bun.lock lockfileVersion is not 1 or 2; re-lock with bun >= 1.3".into(),
+            detail: "bun.lock lockfileVersion is not 0, 1 or 2; re-lock with bun >= 1.4".into(),
         });
         return;
     }
@@ -2423,6 +2424,16 @@ fn rewrite_bun_lock(
         }
     };
 
+    if lock_version(content) == Some(0) && has_workspace_packages(&entries) {
+        result.warnings.push(RewriteWarning {
+            code: "redirect_bun_workspace_unsupported".into(),
+            detail: "Bun version-0 workspace locks cannot preserve hosted tarballs on frozen \
+                     installs; upgrade Bun and regenerate the text lockfile"
+                .into(),
+        });
+        return;
+    }
+
     let mut changed = false;
     for dep in &npm {
         let fname = full_name(dep);
@@ -6604,7 +6615,7 @@ mod tests {
         assert!(r.files.is_empty());
         assert_eq!(r.warnings[0].code, "redirect_bun_lock_unsupported");
         assert!(
-            r.warnings[0].detail.contains("not 1 or 2"),
+            r.warnings[0].detail.contains("not 0, 1 or 2"),
             "the refusal must name the supported versions: {}",
             r.warnings[0].detail
         );

crates/socket-patch-core/src/vendor/bun_lock.rs

@@ -36,8 +36,8 @@ use crate::patch::apply::PatchSources;
 use crate::patch::copy_tree::remove_tree;
 use crate::utils::fs::atomic_write_bytes_preserving_mode;
 use crate::vendor::bun_lock_text::{
-    check_lock_version, decode_json_string, packages_bounds, parse_entry_line,
-    parse_packages_section, split_name_spec, BunEntry,
+    check_lock_version, decode_json_string, has_workspace_packages, lock_version, packages_bounds,
+    parse_entry_line, parse_packages_section, split_name_spec, BunEntry,
 };
 
 use super::common::{already_patched_result, refused};
@@ -56,6 +56,47 @@ const BUN_LOCK: &str = "bun.lock";
 /// original/new = the verbatim entry LINE.
 const KIND_LOCK_PACKAGE: &str = "bun_lock_package";
 
+fn check_workspace_compatibility(
+    text: &str,
+    entries: &[BunEntry],
+) -> Result<(), (&'static str, String)> {
+    if lock_version(text) != Some(2) && has_workspace_packages(entries) {
+        return Err((
+            "vendor_bun_workspace_unsupported",
+            "Bun text locks before version 2 resolve workspace tarballs relative to the \
+             workspace rather than the lockfile; upgrade to Bun >= 1.4 and run `bun install` \
+             before vendoring workspace dependencies"
+                .to_string(),
+        ));
+    }
+    Ok(())
+}
+
+/// Refuse incompatible Bun projects before downloading records into the manifest.
+/// Other package managers are left to their own backends.
+pub async fn preflight_vendor(project_root: &Path) -> Result<(), (&'static str, String)> {
+    let path = project_root.join(BUN_LOCK);
+    let text = match tokio::fs::read_to_string(&path).await {
+        Ok(text) => text,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
+            if project_root.join("bun.lockb").exists() {
+                return Err((
+                    "vendor_bun_lockb_unsupported",
+                    "Bun binary lockfiles cannot be vendored; upgrade Bun and generate bun.lock"
+                        .to_string(),
+                ));
+            }
+            return Ok(());
+        }
+        Err(error) => return Err(("vendor_lockfile_missing", error.to_string())),
+    };
+    check_lock_version(&text).map_err(|detail| ("vendor_lockfile_version_unsupported", detail))?;
+    let lines = text.split('\n').map(str::to_string).collect::<Vec<_>>();
+    let entries = parse_packages_section(&lines)
+        .map_err(|detail| ("vendor_lockfile_version_unsupported", detail))?;
+    check_workspace_compatibility(&text, &entries)
+}
+
 /// Vendor one installed npm package into a bun project (see the module doc).
 /// Same contract as `npm_lock::vendor_npm`: refuse-early / wire-last,
 /// `entry` present iff `result.success` and not a dry run, and an in-sync
@@ -107,6 +148,10 @@ pub(crate) async fn vendor_bun(
         }
     };
 
+    if let Err((code, detail)) = check_workspace_compatibility(&lock_text, &entries) {
+        return refused(code, detail);
+    }
+
     // ── 3. Pre-flight: at least one rewritable instance ──────────────────
     let target_spec = format!("{name}@{version}");
     let target_leaf = tgz_rel_leaf(name, version);
@@ -1226,6 +1271,66 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn legacy_workspace_tarballs_refuse_before_writes() {
+        for version in [0, 1, 2] {
+            let lock = BN3_BEFORE_LOCK
+                .replace("\"lockfileVersion\": 1", &format!("\"lockfileVersion\": {version}"))
+                .replace("  \"packages\": {", "  \"packages\": {\n    \"consumer\": [\"consumer@workspace:packages/consumer\"],");
+            let fx = fixture_with(&lock, "node_modules/left-pad").await;
+            if version < 2 {
+                assert_eq!(
+                    preflight_vendor(fx.root()).await.unwrap_err().0,
+                    "vendor_bun_workspace_unsupported"
+                );
+                expect_refused(fx.vendor(false).await, "vendor_bun_workspace_unsupported");
+                assert_eq!(fx.read_lock().await, lock);
+                assert!(!fx.root().join(".socket/vendor").exists());
+            } else {
+                assert!(preflight_vendor(fx.root()).await.is_ok());
+                let (_, entry, _) = expect_done(fx.vendor(false).await);
+                assert!(entry.is_some());
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn lock_v0_vendor_and_revert_preserve_bytes() {
+        let lock = BN3_BEFORE_LOCK.replace("\"lockfileVersion\": 1", "\"lockfileVersion\": 0");
+        let fx = fixture_with(&lock, "node_modules/left-pad").await;
+        assert!(preflight_vendor(fx.root()).await.is_ok());
+        let (_, entry, _) = expect_done(fx.vendor(false).await);
+        assert!(fx.read_lock().await.contains(".socket/vendor/npm/"));
+        let entry = entry.unwrap();
+        let result = revert_bun(&entry, fx.root(), false).await;
+        assert!(result.success);
+        assert_eq!(fx.read_lock().await, lock);
+    }
+
+    #[tokio::test]
+    async fn download_preflight_refuses_binary_and_malformed_bun_locks() {
+        let root = tempfile::tempdir().unwrap();
+        assert!(preflight_vendor(root.path()).await.is_ok());
+        tokio::fs::write(root.path().join("bun.lockb"), b"binary")
+            .await
+            .unwrap();
+        assert_eq!(
+            preflight_vendor(root.path()).await.unwrap_err().0,
+            "vendor_bun_lockb_unsupported"
+        );
+        tokio::fs::write(root.path().join(BUN_LOCK), BN3_BEFORE_LOCK)
+            .await
+            .unwrap();
+        assert!(preflight_vendor(root.path()).await.is_ok());
+        tokio::fs::write(root.path().join(BUN_LOCK), "{}")
+            .await
+            .unwrap();
+        assert_eq!(
+            preflight_vendor(root.path()).await.unwrap_err().0,
+            "vendor_lockfile_version_unsupported"
+        );
+    }
+
     /// Build a scoped-package fixture and vendor it once (not dry).
     async fn scoped_fixture() -> Fixture {
         let fx = fixture_with(SCOPED_BEFORE_LOCK, "node_modules/@scope/pkg").await;

crates/socket-patch-core/src/vendor/bun_lock_text.rs

@@ -11,6 +11,7 @@
 
 /// The text-lockfile versions the surgery has byte-exact fixtures for.
 ///
+/// Bun 1.1.39–1.1.45 emits 0 with the same package tuple grammar.
 /// bun 1.3.x emits 1 (spike pinned 1.3.14). bun 1.4.0 bumped the default to
 /// 2 (oven-sh/bun PR #31539): the bump gates stricter PARSE checks —
 /// integrity hashes required for off-registry npm tarballs, unsafe git
@@ -19,7 +20,7 @@
 /// this integer; verified empirically). Our URL/local 3-tuples always carry
 /// a sha512, so they satisfy the v2 off-registry-integrity rule by
 /// construction.
-const SUPPORTED_LOCK_VERSIONS: [u64; 2] = [1, 2];
+const SUPPORTED_LOCK_VERSIONS: [u64; 3] = [0, 1, 2];
 
 /// One parsed single-line packages entry.
 pub(crate) struct BunEntry {
@@ -50,25 +51,39 @@ pub(crate) fn split_name_spec(s: &str) -> Option<(&str, &str)> {
 /// `"lockfileVersion": <n>` head check — only the fixture-pinned text
 /// lockfile versions are spliced (fail-closed on anything newer/older).
 pub(crate) fn check_lock_version(text: &str) -> Result<(), String> {
-    let version = text.lines().take(5).find_map(|line| {
-        line.trim()
-            .strip_prefix("\"lockfileVersion\":")
-            .map(|rest| rest.trim().trim_end_matches(',').to_string())
-    });
-    match version.as_deref().map(str::parse::<u64>) {
-        Some(Ok(v)) if SUPPORTED_LOCK_VERSIONS.contains(&v) => Ok(()),
-        Some(Ok(v)) => Err(format!(
-            "bun.lock has lockfileVersion {v}; only 1 and 2 are supported — \
-             re-lock with bun >= 1.3"
+    match lock_version(text) {
+        Some(v) if SUPPORTED_LOCK_VERSIONS.contains(&v) => Ok(()),
+        Some(v) => Err(format!(
+            "bun.lock has lockfileVersion {v}; only 0, 1 and 2 are supported — \
+             re-lock with bun >= 1.4"
         )),
-        _ => Err(
-            "bun.lock has no integer lockfileVersion in its head; only 1 and 2 \
-             are supported — re-lock with bun >= 1.3"
+        None => Err(
+            "bun.lock has no integer lockfileVersion in its head; only 0, 1 and 2 \
+             are supported — re-lock with bun >= 1.4"
                 .to_string(),
         ),
     }
 }
 
+pub(crate) fn lock_version(text: &str) -> Option<u64> {
+    text.lines()
+        .take(5)
+        .find_map(|line| line.trim().strip_prefix("\"lockfileVersion\":"))
+        .and_then(|rest| rest.trim().trim_end_matches(',').parse().ok())
+}
+
+pub(crate) fn has_workspace_packages(entries: &[BunEntry]) -> bool {
+    entries.iter().any(|entry| {
+        entry
+            .elems
+            .first()
+            .and_then(|raw| decode_json_string(raw))
+            .is_some_and(|spec| {
+                split_name_spec(&spec).is_some_and(|(_, version)| version.starts_with("workspace:"))
+            })
+    })
+}
+
 /// `(header_idx, close_idx)` of the `"packages": {` section.
 pub(crate) fn packages_bounds(lines: &[String]) -> Option<(usize, usize)> {
     let start = lines
@@ -445,18 +460,18 @@ mod tests {
     /// same-fixture locks are byte-identical except the integer). Both must
     /// pass; anything else — or a missing/non-integer head — fails closed.
     #[test]
-    fn lock_version_gate_accepts_1_and_2_only() {
-        for v in [1u64, 2] {
+    fn lock_version_gate_accepts_0_1_and_2_only() {
+        for v in [0u64, 1, 2] {
             assert!(
                 check_lock_version(&format!("{{\n  \"lockfileVersion\": {v},\n}}\n")).is_ok(),
                 "lockfileVersion {v} must be accepted"
             );
         }
-        for v in [0u64, 3, 99] {
+        for v in [3u64, 99] {
             let err =
                 check_lock_version(&format!("{{\n  \"lockfileVersion\": {v},\n}}\n")).unwrap_err();
             assert!(
-                err.contains(&v.to_string()) && err.contains("re-lock with bun >= 1.3"),
+                err.contains(&v.to_string()) && err.contains("re-lock with bun >= 1.4"),
                 "the refusal must name the found version and the remedy: {err}"
             );
         }

crates/socket-patch-core/tests/fixtures/redirect/npm/bun/lock-v0-workspace-refusal/expected-edits.json

@@ -0,0 +1 @@
+[]