pnpm 11.28.7

Source: https://github.com/pnpm/pnpm
Tag scanned: v11.28.7
Directory: pnpm11/pnpm (only this part of the repository was scanned)
Compared with: v11.28.6 (0 signals introduced since)
Files: 217 scanned, 10 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 21 info
Scan time: 14.2 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 20 of 20 warn and critical signals; 20 demoted to info.
Disclude version: 4.1.0
Scanned (UTC): 2026-10-21 23:29

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

info ~~warn~~ → info by review dynamic-execution pnpm11/pnpm/artifacts/exe/README.md:12:1

[markup prose] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
curl -fsSL https://get.pnpm.io/install.sh | sh -
```
likely benign LLM, confidence 0.90 README instruction to install pnpm via curl piped to sh from the official get.pnpm.io host.
Reasoning
This is the documented one-line installer for pnpm in a markdown README. Piping a vendor install script to sh is a common, publicly documented install method, and the markdown context shows no hidden or obfuscated behavior.
info ~~warn~~ → info by review dynamic-execution pnpm11/pnpm/artifacts/exe/README.md:18:1

[markup prose] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
wget -qO- https://get.pnpm.io/install.sh | sh -
```
likely benign LLM, confidence 0.90 README instruction to install pnpm via wget piped to sh from the official get.pnpm.io host.
Reasoning
Same documented pnpm installer, here using wget. It is a visible README instruction for a well-known tool, not an embedded payload.
info ~~critical~~ → info by review dynamic-execution pnpm11/pnpm/artifacts/exe/pn:79:1

`exec` called with a dynamic (variable/substitution) path (ast pass, confidence 0.85)
```
exec "$pnpm" "$@"
```
likely benign LLM, confidence 0.80 Bash shim that execs a resolved pnpm binary with the forwarded arguments.
Reasoning
This is the pnpm launcher script. It resolves the pnpm binary path into a variable and then execs it with the user's arguments. A dynamic exec path is inherent to a shim that delegates to a resolved binary, and the snippet shows no download or decoding step.
info ~~critical~~ → info by review dynamic-execution pnpm11/pnpm/artifacts/exe/pnpx:79:1

`exec` called with a dynamic (variable/substitution) path (ast pass, confidence 0.85)
```
exec "$pnpm" dlx "$@"
```
likely benign LLM, confidence 0.85 Bash shim that runs pnpm dlx with forwarded arguments through a resolved binary path.
Reasoning
Standard pnpx wrapper that execs the resolved pnpm binary with the dlx subcommand and the user's arguments. The dynamic path is the expected design of a launcher, and nothing in the snippet is malicious.
info ~~critical~~ → info by review dynamic-execution pnpm11/pnpm/artifacts/exe/pnx:79:1

`exec` called with a dynamic (variable/substitution) path (ast pass, confidence 0.85)
```
exec "$pnpm" dlx "$@"
```
likely benign LLM, confidence 0.85 Bash shim that runs pnpm dlx with forwarded arguments through a resolved binary path.
Reasoning
Same pattern as pnpx: a thin launcher that execs the resolved pnpm binary with dlx and user arguments. The critical severity reflects the exec pattern alone, not any malicious behavior.
info identifier-low-length pnpm11/pnpm/src/shorthands.ts:1:1

20 of 36 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/install/global.ts:77:41

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  expect(isPositivePath).toBeTruthy()
  const { default: isPositive } = await import(isPositivePath!)
  expect(typeof isPositive).toBe('function')
```
likely benign LLM, confidence 0.90 Test imports a locally computed fixture module path and checks its default export.
Reasoning
Test code that dynamically imports a fixture path computed by the test itself to check that a module is a function. This is a normal test pattern, and the specifier comes from local test setup, not untrusted input.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/install/global.ts:82:41

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  expect(isNegativePath).toBeTruthy()
  const { default: isNegative } = await import(isNegativePath!)
  expect(typeof isNegative).toBe('function')
})
```
likely benign LLM, confidence 0.90 Test imports a second locally computed fixture module and checks its default export.
Reasoning
Same test pattern: a dynamic import of a locally resolved fixture path to verify a function export. The specifier is test-controlled, so this is not a supply-chain risk.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/install/global.ts:118:41

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  expect(isPositivePath).toBeTruthy()
  const { default: isPositive } = await import(isPositivePath!)
  expect(typeof isPositive).toBe('function')
})
```
likely benign LLM, confidence 0.90 Test dynamically imports a computed fixture path and asserts the export type.
Reasoning
Repeated test fixture import with a computed path, used to assert a function export. This is ordinary test scaffolding.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/install/global.ts:137:17

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  expect(peerCPath).toBeTruthy()
  expect((await import(path.join(peerCPath!, 'package.json'))).default.version).toBe('2.0.0')
})
```
likely benign LLM, confidence 0.90 Test dynamically imports a package.json from a computed path to check its version.
Reasoning
Test reads a package.json through a dynamic import built from a test-computed peer path to check its version. This is ordinary test verification with no hostile intent.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/install/hooks.ts:657:21

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  const pkg = await import(path.resolve('package.json'))
  expect(pkg.dependencies).toBeFalsy()
})
```
likely benign LLM, confidence 0.92 Test imports the local package.json via path.resolve to inspect its dependencies.
Reasoning
Test imports package.json from a path resolved relative to the working directory to check its dependencies. This is a standard way to read manifests in a test suite.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/install/lifecycleScripts.ts:146:34

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  const { default: pkg } = await import(path.resolve('package.json'))
  expect(pkg).toEqual(initialPkg)
})
```
likely benign LLM, confidence 0.92 Test imports the local package.json to compare it with an expected manifest.
Reasoning
Test imports the local package.json via path.resolve and compares it with the initial manifest. Ordinary test behavior, with no obfuscation or attacker-controlled specifier.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/install/misc.ts:277:17

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  expect((await import(path.resolve('package.json'))).default).toEqual({
    dependencies: {
      '@pnpm.e2e/dep-of-pkg-with-1-dep': '100.1.0',
```
likely benign LLM, confidence 0.92 Test imports the local package.json and asserts its dependency map.
Reasoning
Test imports the local package.json via path.resolve and checks its dependencies against an expected object. Standard test verification.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/monorepo/index.ts:168:34

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  const { default: pkg } = await import(path.resolve('package.json'))

  expect(pkg?.dependencies).toEqual({ 'project-2': 'workspace:^' }) // spec of linked package added to dependencies
```
likely benign LLM, confidence 0.92 Monorepo test imports the local package.json to assert workspace dependency entries.
Reasoning
Monorepo test imports the local package.json via path.resolve to check workspace dependency specs. This is normal test verification.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/monorepo/index.ts:213:34

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  const { default: pkg } = await import(path.resolve('package.json'))

  expect(pkg?.dependencies).toEqual({ 'project-2': 'workspace:^' }) // spec of linked package added to dependencies
```
likely benign LLM, confidence 0.92 Monorepo test imports the local package.json to assert linked workspace dependencies.
Reasoning
Same monorepo test pattern: importing the local package.json to verify linked workspace dependencies. Benign test code.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/recursive/update.ts:53:17

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  expect((await import(path.resolve('project-1/package.json'))).dependencies).toStrictEqual({ foo: '^100.1.0' })
  expect((await import(path.resolve('project-2/package.json'))).dependencies).toStrictEqual({ foo: '100.1.0' })
```
likely benign LLM, confidence 0.92 Test imports per-project package.json files to verify updated dependency ranges.
Reasoning
Recursive update test imports several project package.json files via path.resolve to check dependency ranges after an update. This is ordinary test code with fixed project paths.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/recursive/update.ts:54:17

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  expect((await import(path.resolve('project-2/package.json'))).dependencies).toStrictEqual({ foo: '100.1.0' })
  expect((await import(path.resolve('project-3/package.json'))).dependencies).toStrictEqual({ foo: '~100.1.0' })
})
```
likely benign LLM, confidence 0.92 Test imports additional project package.json files to check updated dependency ranges.
Reasoning
Continuation of the same recursive update test, importing further project manifests with fixed paths to assert version ranges. Benign.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/recursive/update.ts:55:17

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  expect((await import(path.resolve('project-2/package.json'))).dependencies).toStrictEqual({ foo: '100.1.0' })
  expect((await import(path.resolve('project-3/package.json'))).dependencies).toStrictEqual({ foo: '~100.1.0' })
})
```
likely benign LLM, confidence 0.90 Test reads fixture package.json files via dynamic import to check dependency versions.
Reasoning
Dynamic import of a path.resolve'd local package.json inside a test file that asserts dependency versions. Non-literal specifier is common in tests reading fixture files; no obfuscation or malicious payload is present.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/run.ts:29:35

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  const { default: args } = await import(path.resolve('project/args.json'))
  expect(args).toStrictEqual([
    [],
```
likely benign LLM, confidence 0.90 Test loads a local args.json fixture through a dynamic import.
Reasoning
Test helper imports a local args.json fixture via path.resolve and compares the result. Benign test scaffolding; the AST rule is generic and fires on any non-literal import.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/run.ts:51:35

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  const { default: args } = await import(path.resolve('args.json'))
  expect(args).toStrictEqual([
    [],
```
likely benign LLM, confidence 0.90 Test loads args.json fixture via dynamic import and asserts its contents.
Reasoning
Same pattern as the other test in this file: a dynamic import of a local JSON fixture followed by an equality assertion. No execution of fetched or decoded content.
info ~~warn~~ → info by review dynamic-import pnpm11/pnpm/test/run.ts:76:35

dynamic `import(...)` with a non-literal specifier (ast pass, confidence 0.65)
```
  const { default: args } = await import(path.resolve('args.json'))
  expect(args).toStrictEqual([
    [],
```
likely benign LLM, confidence 0.90 Test loads args.json fixture via dynamic import and checks it.
Reasoning
Identical fixture-loading pattern in a test file, importing a local args.json with path.resolve and asserting on the value. Benign.

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.1.0
git clone https://github.com/pnpm/pnpm pnpm && cd pnpm
git checkout v11.28.7
disclude scan --severity info --diff v11.28.6 pnpm11/pnpm