Fix 15 open pnpm issues across hosted, vendored and agent modes

crates/socket-patch-bench/src/fixtures/npm.rs

@@ -478,9 +478,11 @@ pub fn build_pnpm(t: &mut Tree, size: Size) -> std::io::Result<Fixture> {
             &format!("project/node_modules/{}", p.name),
         )?;
     }
+    // pnpm >= 11, so the scan still writes the `trustLockfile` scaffold (a
+    // pnpm 9.0-10.4 install record skips it, #734).
     t.write(
         "project/node_modules/.modules.yaml",
-        "layoutVersion: 5\nnodeLinker: isolated\npackageManager: pnpm@9.15.0\n",
+        "layoutVersion: 5\nnodeLinker: isolated\npackageManager: pnpm@11.0.0\n",
     )?;
     t.write("project/node_modules/.pnpm/lock.yaml", pnpm_lock(&g))?;
     t.mkdir("home")?;

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

@@ -27,7 +27,10 @@ use crate::commands::lock_cli::acquire_or_emit;
 use crate::commands::vex::{
     generate_vex_from_manifest_path, generate_vex_without_manifest, ManifestlessVex, VexEmbedArgs,
 };
-use crate::ecosystem_dispatch::{find_all_packages_for_purls, partition_purls, JvmScope};
+use crate::ecosystem_dispatch::{
+    distinct_install_dirs, distinct_npm_copies, find_all_packages_for_purls, partition_purls,
+    JvmScope,
+};
 use crate::json_envelope::{
     AppliedVia, Command, Envelope, EnvelopeError, PatchAction, PatchEvent, PatchEventFile,
     RunWarning, Status, VexSummary,
@@ -671,25 +674,6 @@ pub(crate) fn variant_matches_installed(first_file_status: Option<&VerifyStatus>
     }
 }
 
-/// `paths` in order with every path that resolves to an already-listed
-/// directory dropped: two discovered site-packages paths can name ONE
-/// directory (a `lib64 -> lib` symlink, a symlinked venv), and patching it
-/// twice would report the second pass `already_patched`. A path that can't
-/// be canonicalized is kept as-is.
-async fn distinct_install_dirs(paths: &[PathBuf]) -> Vec<PathBuf> {
-    let mut seen: HashSet<PathBuf> = HashSet::new();
-    let mut out = Vec::with_capacity(paths.len());
-    for path in paths {
-        let key = tokio::fs::canonicalize(path)
-            .await
-            .unwrap_or_else(|_| path.clone());
-        if seen.insert(key) {
-            out.push(path.clone());
-        }
-    }
-    out
-}
-
 /// The file whose verify status decides whether a release variant
 /// describes the installed distribution (fed to
 /// [`variant_matches_installed`]).
@@ -1984,12 +1968,15 @@ async fn apply_patches_inner(
     // physical copy per PURL. Patching only one would leave a live,
     // vulnerable copy while reporting success (the multi-copy silent
     // partial). The apply loop below iterates every copy.
-    let all_packages = find_all_packages_for_purls(
+    let mut all_packages = find_all_packages_for_purls(
         &partitioned,
         &crawler_options,
         args.common.silent || args.common.json,
     )
     .await;
+    // One visit per physical copy: a pnpm workspace member's link into
+    // the root store is the same copy the root walk found (#633).
+    distinct_npm_copies(&mut all_packages).await;
 
     if all_packages.is_empty() {
         // Vendored purls are already accounted for (synthesized Skipped/

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

@@ -1770,16 +1770,8 @@ async fn lock_text_refusals_for(
         .filter(|url| !url.trim().is_empty())
         .cloned()
         .collect();
-    let pins = socket_patch_core::patch::redirect::upstream::HostedPin::all(
-        &socket_patch_core::vex::discover_patched_refs_with(
-            cwd,
-            &socket_patch_core::vex::DiscoverOptions {
-                patch_server_origins: origins.clone(),
-            },
-        )
-        .await,
-    );
-    let claimed: Vec<String> = pins.iter().map(|pin| canonical_purl(&pin.purl)).collect();
+    let pins = hosted_pins(cwd, origins.clone()).await;
+    let claimed = claimed_purls(&pins);
     let fetchable: Vec<&PatchSearchResult> = selected
         .iter()
         .filter(|sr| bun_refusal.filter(|r| r.applies_to(&sr.purl)).is_none())
@@ -1825,6 +1817,37 @@ async fn lock_text_refusals_for(
     refusals
 }
 
+/// The canonical purls the project's lockfiles pin hosted (a patch-server
+/// tarball, Socket's own or one of `origins`): the purls whose vendored
+/// run is a hosted → vendored takeover.
+/// The fetch-phase gate ([`lock_text_refusals_for`]) and the scan preview
+/// (`scan/vendor_flow.rs`) both read the takeovers through here, so the dry
+/// run and the wet run agree on which purls they are.
+pub(crate) async fn hosted_claimed_purls(cwd: &Path, origins: Vec<String>) -> Vec<String> {
+    claimed_purls(&hosted_pins(cwd, origins).await)
+}
+
+/// The project's hosted pins (see [`hosted_claimed_purls`]).
+async fn hosted_pins(
+    cwd: &Path,
+    origins: Vec<String>,
+) -> Vec<socket_patch_core::patch::redirect::upstream::HostedPin> {
+    socket_patch_core::patch::redirect::upstream::HostedPin::all(
+        &socket_patch_core::vex::discover_patched_refs_with(
+            cwd,
+            &socket_patch_core::vex::DiscoverOptions {
+                patch_server_origins: origins,
+            },
+        )
+        .await,
+    )
+}
+
+/// The canonical purls of `pins`.
+fn claimed_purls(pins: &[socket_patch_core::patch::redirect::upstream::HostedPin]) -> Vec<String> {
+    pins.iter().map(|pin| canonical_purl(&pin.purl)).collect()
+}
+
 /// The record a detached ledger entry already carries for `purl` at
 /// exactly `uuid` — the ledger store's idempotency skip (no view fetch).
 /// Always `None` for the manifest store.
@@ -3789,7 +3812,13 @@ async fn run_get_vendored(
             selected.iter().map(|p| p.purl.as_str()),
         )
         .await;
-        let preview = super::scan::preview_vendor_json(&args.common.cwd, selected, &takeover).await;
+        let preview = super::scan::preview_vendor_json(
+            &args.common.cwd,
+            selected,
+            &super::rollback::patch_server_origins(&args.common),
+            &takeover,
+        )
+        .await;
         if args.common.json {
             let mut result = serde_json::json!({
                 "status": "success",

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

@@ -26,7 +26,9 @@ use crate::args::{apply_env_toggles, parse_bool_flag, GlobalArgs};
 use crate::commands::apply::is_local_go;
 use crate::commands::lock_cli::acquire_or_emit;
 use crate::commands::vendored_backend::{RevertedEntry, VendorRevertStep, VendoredBackend};
-use crate::ecosystem_dispatch::{find_all_packages_for_rollback, partition_purls, JvmScope};
+use crate::ecosystem_dispatch::{
+    distinct_npm_copies, find_all_packages_for_rollback, partition_purls, JvmScope,
+};
 use crate::json_envelope::Command as EnvelopeCommand;
 use crate::looks_like_uuid;
 use crate::ui::{plural, StatusLine};
@@ -2160,12 +2162,14 @@ pub(crate) async fn rollback_patches_inner(
     // one would leave the other copy still patched (silently divergent from
     // the manifest's rolled-back state). The rollback loop below restores
     // every copy.
-    let all_packages_multi = find_all_packages_for_rollback(
+    let mut all_packages_multi = find_all_packages_for_rollback(
         &partitioned,
         &crawler_options,
         common.silent || common.json,
     )
     .await;
+    // One restore per physical copy, as apply patches them (#633).
+    distinct_npm_copies(&mut all_packages_multi).await;
 
     // One representative path per PURL for the "is it installed" checks and
     // the abort envelope's path display. The before-blob gate and the

crates/socket-patch-cli/src/commands/scan/hosted.rs

@@ -1849,6 +1849,23 @@ async fn vendored_takeover(
     } else {
         None
     };
+    // pnpm twin: under `gitBranchLockfile` with a branch lock, the hosted
+    // rewrite leaves every pnpm lock alone (#556), so a vendored pnpm entry
+    // stays vendored rather than be reverted into neither mode.
+    let pnpm_entry = |entry: &socket_patch_core::vendor::VendorEntry| {
+        entry.ecosystem == "npm" && matches!(entry.flavor.as_deref(), Some("pnpm" | "pnpm-legacy"))
+    };
+    let pnpm_takeover_refusal = if takeover
+        .iter()
+        .any(|(_, entry)| entry.as_ref().is_some_and(pnpm_entry))
+    {
+        let view = socket_patch_core::vendor::lock_inventory::ProjectView::Disk(&common.cwd);
+        socket_patch_core::utils::pnpm_workspace::git_branch_locks(&view)
+            .await
+            .map(|branch| socket_patch_core::hosted::engine::git_branch_lock_refusal(&branch))
+    } else {
+        None
+    };
     // Gradle twin: the hosted Gradle planner refuses builds and grants the
     // vendored backend accepts (a custom `lockFile`, a settings-classpath
     // GA, a same-GAV or incomplete grant, ...). Each refusal must be known
@@ -1881,7 +1898,7 @@ async fn vendored_takeover(
         std::collections::HashMap::new()
     };
     // The takeover refusal (if any) for one candidate: bun gates every
-    // npm purl, berry and vlt only their own vendored entries, Gradle each
+    // npm purl, berry, vlt and pnpm only their own vendored entries, Gradle each
     // of its own purls, a pypi purl on a platform-tagged grant (#701), and a
     // requirements.txt entry on the hosted rewriter's reach (it pins only
     // the root file, #699). Berry also runs
@@ -1929,6 +1946,11 @@ async fn vendored_takeover(
                     .clone()
                     .filter(|_| entry.is_some_and(vlt_entry))
             })
+            .or_else(|| {
+                pnpm_takeover_refusal
+                    .clone()
+                    .filter(|_| entry.is_some_and(pnpm_entry))
+            })
     };
     // SYMLINK PRE-CHECK for the takeover reverts — the same rule as the
     // SYMLINK GUARD below, applied to each ledger entry's recorded wiring

crates/socket-patch-cli/src/commands/scan/mod.rs

@@ -30,7 +30,10 @@ use std::path::{Path, PathBuf};
 
 use crate::args::{apply_env_toggles, GlobalArgs};
 use crate::commands::vex::{generate_vex_from_manifest_path, VexEmbedArgs};
-use crate::ecosystem_dispatch::{crawl_ecosystems, crawl_ecosystems_with_npm};
+use crate::ecosystem_dispatch::{
+    crawl_ecosystems, crawl_ecosystems_with_npm, find_all_packages_for_rollback_reusing,
+    partition_purls,
+};
 use crate::ui::{self, plural, print_json, StatusLine};
 
 use super::get::{download_and_apply_patches_with, DownloadParams, DownloadRun};
@@ -1779,7 +1782,11 @@ async fn run_scan(
     // Crawl packages. Vendored mode keeps the npm half for its engine to
     // reuse; hosted mode keeps it only for an embedded `--vex` (skipped
     // under `--dry-run`). No other run pays for copying the snapshot.
-    let keep_npm = vendor || (hosted && args.vex.vex.is_some() && !args.common.dry_run);
+    // A path-scoped (agent or mode-less) run keeps it to resolve every
+    // installed copy for the scope filter below.
+    let keep_npm = vendor
+        || (hosted && args.vex.vex.is_some() && !args.common.dry_run)
+        || !path_scope.is_empty();
     let (mut all_crawled, mut eco_counts, skipped_bundle_config_path, npm_crawl) = if keep_npm {
         crawl_ecosystems_with_npm(&crawler_options, crawl_scope).await
     } else {
@@ -1925,7 +1932,10 @@ async fn run_scan(
 
     // PATH scoping, strictly AFTER the `scanned_purls` capture. A purl is
     // in scope when ANY genuinely-crawled copy of it sits under a matching
-    // path.
+    // path. The crawl keeps one record per purl (for npm, the first copy
+    // the walk meets: a pnpm workspace's root `.pnpm` store entry, not the
+    // member's link to it), so a purl whose record misses is resolved to
+    // every installed copy the way `rollback`'s path targets are.
     let filtered_crawled: Vec<_> = if path_scope.is_empty() {
         filtered_crawled
     } else {
@@ -1952,12 +1962,35 @@ async fn run_scan(
             ));
         }
         let scope = path_scope.bind(&args.common.cwd);
-        let in_scope: HashSet<String> = filtered_crawled
+        let mut in_scope: HashSet<String> = filtered_crawled
             .iter()
             .filter(|pkg| !supplement_purls.contains(&pkg.purl))
             .filter(|pkg| scope.matches(&pkg.path))
             .map(|pkg| pkg.purl.clone())
             .collect();
+        let mut unresolved: Vec<String> = filtered_crawled
+            .iter()
+            .filter(|pkg| !supplement_purls.contains(&pkg.purl) && !in_scope.contains(&pkg.purl))
+            .map(|pkg| pkg.purl.clone())
+            .collect();
+        unresolved.sort();
+        unresolved.dedup();
+        if !unresolved.is_empty() {
+            let partitioned = partition_purls(&unresolved, args.common.ecosystems.as_deref());
+            let copies = find_all_packages_for_rollback_reusing(
+                &partitioned,
+                &crawler_options,
+                true,
+                npm_crawl.as_ref(),
+            )
+            .await;
+            in_scope.extend(
+                copies
+                    .into_iter()
+                    .filter(|(_, paths)| paths.iter().any(|p| scope.matches(p)))
+                    .map(|(purl, _)| purl),
+            );
+        }
         filtered_crawled
             .into_iter()
             .filter(|pkg| in_scope.contains(&pkg.purl))
@@ -3069,7 +3102,15 @@ async fn run_scan(
                     selected.iter().map(|p| p.purl.as_str()),
                 )
                 .await;
-                Some(preview_vendor_json(&args.common.cwd, &selected, &takeover).await)
+                Some(
+                    preview_vendor_json(
+                        &args.common.cwd,
+                        &selected,
+                        &crate::commands::rollback::patch_server_origins(&args.common),
+                        &takeover,
+                    )
+                    .await,
+                )
             } else {
                 None
             };