npm / playwright-core / 1.65.0-alpha-2026-10-16

playwright-core 1.65.0-alpha-2026-10-16

Source: https://github.com/microsoft/playwright
Commit scanned: 034f230cc68b (recorded by npm)
Directory: packages/playwright-core (only this part of the repository was scanned)
Compared with: a038fe7e0eb9 (0 signals introduced since)
Files: 370 scanned, 49 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 1 warn · 25 info
Scan time: 16.8 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 17 of 17 warn and critical signals; 16 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-16 23:26

Signals

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

warn dynamic-import packages/playwright-core/src/tools/backend/tab.ts:189:35

`require` called with a non-literal specifier (ast pass, confidence 0.60)
```
      try {
        const { default: func } = require(initPage);
        await func({ page: this.page });
      } catch (e) {
```
likely benign LLM, confidence 0.60 Dynamic require of an init-page module that is then invoked with the browser page.
Reasoning
The require uses a variable initPage, so the module path is not literal. The snippet shows it is an init hook called with the page, which fits a configurable setup script in a browser automation tool. Nothing shown is encoded or hidden. Loading a path from configuration is still a code-execution surface, so this is not fully settled from the snippet alone.
info ~~warn~~ → info by review obfuscated-command-name packages/playwright-core/bin/reinstall_chrome_beta_mac.sh:13:1

command name contains 4 backslash-escape sequences — hiding the true command (ast pass, confidence 0.85)
```
/Applications/Google\ Chrome\ Beta.app/Contents/MacOS/Google\ Chrome\ Beta --version
```
likely benign LLM, confidence 0.90 Invokes the Chrome Beta binary on macOS with --version, with spaces in the path escaped.
Reasoning
The backslash escapes are ordinary bash quoting for spaces in the macOS application bundle path. The command is a plain version check on Chrome Beta, so nothing is hidden.
info ~~warn~~ → info by review obfuscated-command-name packages/playwright-core/bin/reinstall_msedge_beta_mac.sh:11:1

command name contains 4 backslash-escape sequences — hiding the true command (ast pass, confidence 0.85)
```
rm -rf /tmp/msedge_beta.pkg
/Applications/Microsoft\ Edge\ Beta.app/Contents/MacOS/Microsoft\ Edge\ Beta --version
```
likely benign LLM, confidence 0.90 Removes a temp package and runs the Microsoft Edge Beta binary with --version.
Reasoning
The escapes are standard shell quoting for spaces in the Edge Beta app path. The script removes a temporary package and then runs a version check, which is routine for a reinstall helper.
info ~~warn~~ → info by review obfuscated-command-name packages/playwright-core/bin/reinstall_msedge_dev_mac.sh:11:1

command name contains 4 backslash-escape sequences — hiding the true command (ast pass, confidence 0.85)
```
rm -rf /tmp/msedge_dev.pkg
/Applications/Microsoft\ Edge\ Dev.app/Contents/MacOS/Microsoft\ Edge\ Dev --version
```
likely benign LLM, confidence 0.90 Removes a temp package and runs the Microsoft Edge Dev binary with --version.
Reasoning
Same pattern as the Edge Beta script: escaped spaces in the app path for a version check, with no obfuscation of the command itself.
info ~~warn~~ → info by review dynamic-import packages/playwright-core/src/cli/installActions.ts:49:25

`require` called with a non-literal specifier (ast pass, confidence 0.60)
```
      continue;
    const packageJSON = require(path.join(browser.referenceDir, 'package.json'));
    const version = packageJSON.version;
    dirToVersion.set(browser.referenceDir, version);
```
likely benign LLM, confidence 0.92 Reads a package.json from a browser reference directory to get its version.
Reasoning
The require argument is path.join of a browser reference directory and the literal 'package.json'. The target is a fixed file name inside a known directory, so this is a normal dynamic JSON load.

info long-line packages/playwright-core/src/client/channels.d.ts:18:1

line length 614 characters (raw pass, confidence 0.50)

import type { Binary, Channel, AndroidWebView, AndroidSelector, AndroidElementInfo, APIResponse, Metadata, ClientSideCallMetadata, SDKLanguage, WaitInfo, HttpCredentials, SetNetworkCookie, NetworkCookie, ResourceTiming, SecurityDetails, RequestSizes, RemoteAddr, ExpectedTextValue, SelectorEngine, FormField, LifecycleEv

info long-line packages/playwright-core/src/client/channels.d.ts:19:1

line length 614 characters (raw pass, confidence 0.50)

export type { Binary, Channel, AndroidWebView, AndroidSelector, AndroidElementInfo, APIResponse, Metadata, ClientSideCallMetadata, SDKLanguage, WaitInfo, HttpCredentials, SetNetworkCookie, NetworkCookie, ResourceTiming, SecurityDetails, RequestSizes, RemoteAddr, ExpectedTextValue, SelectorEngine, FormField, LifecycleEv

info ~~warn~~ → info by review dynamic-import packages/playwright-core/src/package.ts:22:28

`require` called with a non-literal specifier (ast pass, confidence 0.60)
```
export const packageRoot = path.join(__dirname, '..');
export const packageJSON = require(path.join(packageRoot, 'package.json'));
export const binPath = path.join(packageRoot, 'bin');
```
likely benign LLM, confidence 0.92 Loads the package's own package.json via a path-joined require.
Reasoning
The path is built from the package root and the literal 'package.json', which is the standard way to load a package's own manifest.
info dynamic-execution packages/playwright-core/src/server/android/driver/gradlew:143:6

command name is a variable (`$cygwin`) that this file sets only to plain text (ast pass, confidence 0.40)
```
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
    case $MAX_FD in #(
      max*)
```
info dynamic-execution packages/playwright-core/src/server/android/driver/gradlew:143:21

command name is a variable (`$darwin`) that this file sets only to plain text (ast pass, confidence 0.40)
```
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
    case $MAX_FD in #(
      max*)
```
info dynamic-execution packages/playwright-core/src/server/android/driver/gradlew:143:36

command name is a variable (`$nonstop`) that this file sets only to plain text (ast pass, confidence 0.40)
```
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
    case $MAX_FD in #(
      max*)
```

info dynamic-execution packages/playwright-core/src/server/android/driver/gradlew:166:4

command name is a variable (`$cygwin`) that this file sets only to plain text (ast pass, confidence 0.40)

# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )

info dynamic-execution packages/playwright-core/src/server/android/driver/gradlew:166:17

command name is a variable (`$msys`) that this file sets only to plain text (ast pass, confidence 0.40)

# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )

info ~~critical~~ → info by review dynamic-execution packages/playwright-core/src/server/android/driver/gradlew:233:1

`eval` called on a dynamic (variable/substitution) expression (ast pass, confidence 0.90)
```
eval "set -- $(
        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
        xargs -n1 |
```
likely benign LLM, confidence 0.90 Gradle wrapper eval that splits DEFAULT_JVM_OPTS and related options into arguments.
Reasoning
This is the standard Gradle wrapper idiom for splitting JVM options safely with eval set --. It is upstream boilerplate, not attacker-controlled code.
info ~~critical~~ → info by review dynamic-execution packages/playwright-core/src/server/android/driver/gradlew:240:1

`exec` called with a dynamic (variable/substitution) path (ast pass, confidence 0.85)
```
exec "$JAVACMD" "$@"
```
likely benign LLM, confidence 0.90 Gradle wrapper exec that launches the resolved Java binary.
Reasoning
The exec of $JAVACMD is the final launch step of the standard Gradle wrapper, where JAVACMD is resolved from JAVA_HOME or the PATH.

info long-line packages/playwright-core/src/server/channels.d.ts:21:1

line length 614 characters (raw pass, confidence 0.50)

import type { Binary, Channel, AndroidWebView, AndroidSelector, AndroidElementInfo, APIResponse, Metadata, ClientSideCallMetadata, SDKLanguage, WaitInfo, HttpCredentials, SetNetworkCookie, NetworkCookie, ResourceTiming, SecurityDetails, RequestSizes, RemoteAddr, ExpectedTextValue, SelectorEngine, FormField, LifecycleEv

info long-line packages/playwright-core/src/server/channels.d.ts:22:1

line length 614 characters (raw pass, confidence 0.50)

export type { Binary, Channel, AndroidWebView, AndroidSelector, AndroidElementInfo, APIResponse, Metadata, ClientSideCallMetadata, SDKLanguage, WaitInfo, HttpCredentials, SetNetworkCookie, NetworkCookie, ResourceTiming, SecurityDetails, RequestSizes, RemoteAddr, ExpectedTextValue, SelectorEngine, FormField, LifecycleEv

info ~~warn~~ → info by review dynamic-execution packages/playwright-core/src/server/dom.ts:714:43

`atob` decodes a base64 value at runtime — common step before dynamic fetch or eval (ast pass, confidence 0.75)
```
          for (const p of payloads) {
            const bytes = Uint8Array.from(atob(p.buffer), c => c.charCodeAt(0));
            const file = new File([bytes], p.name, { type: p.mimeType, lastModified: p.lastModifiedMs });
            dt.items.add(file);
```
likely benign LLM, confidence 0.80 Decodes base64 file payloads to construct File objects for a simulated drop.
Reasoning
The atob decodes base64 file payloads and builds File objects for a DataTransfer drop simulation. The decoded bytes are not fetched or evaluated, so this is ordinary data handling in a browser automation library.
info ~~critical~~ → info by review dynamic-execution packages/playwright-core/src/server/javascript.ts:315:7

`Function(...)` called with a non-literal body (ast pass, confidence 0.90)
```
    try {
      new Function('(' + expression + ')');
    } catch (e1) {
      // This means we might have a function shorthand. Try another
```
likely benign LLM, confidence 0.85 Syntax-check probe for an expression string while serializing JavaScript values.
Reasoning
new Function is used only to test whether a serialized expression parses, as a syntax probe for shorthand handling. It does not run untrusted content, which is a common pattern in serializers.
info ~~critical~~ → info by review dynamic-execution packages/playwright-core/src/server/javascript.ts:324:9

`Function(...)` called with a non-literal body (ast pass, confidence 0.90)
```
      try {
        new Function('(' + expression  + ')');
      } catch (e2) {
        // We tried hard to serialize, but there's a weird beast here.
```
likely benign LLM, confidence 0.85 Fallback syntax-check of an expression string in the JavaScript serializer.
Reasoning
This is a second syntax-check fallback using new Function in the same serializer, with the same benign purpose of validating expression syntax.
info ~~warn~~ → info by review dynamic-import packages/playwright-core/src/server/registry/index.ts:1201:30

`require` called with a non-literal specifier (ast pass, confidence 0.60)
```
        linkTarget = (await fs.promises.readFile(linkPath)).toString();
        const browsersJSON = require(path.join(linkTarget, 'browsers.json'));
        const descriptors = readDescriptors(browsersJSON);
        for (const browserName of allDownloadableDirectoriesThatEverExisted) {
```
likely benign LLM, confidence 0.80 Loads browsers.json from a symlink-resolved directory in the registry.
Reasoning
The path is the symlink target joined with the fixed name 'browsers.json', which is a normal config load for the browser registry. The input is local tool configuration.
info ~~warn~~ → info by review dynamic-import packages/playwright-core/src/server/registry/index.ts:1396:38

`require` called with a non-literal specifier (ast pass, confidence 0.60)
```
export const registry = new Registry(require(path.join(packageRoot, 'browsers.json')));

export { runOopDownloadBrowserMain } from './oopDownloadBrowserMain';
```
likely benign LLM, confidence 0.90 Loads the package's browsers.json manifest to construct the registry.
Reasoning
The require loads browsers.json from the package root via path.join, which is the package's own registry manifest. Nothing here is attacker-controlled.
info ~~critical~~ → info by review dynamic-execution packages/playwright-core/src/tools/backend/evaluate.ts:50:25

`eval` called with a non-literal expression (ast pass, confidence 0.90)
```
        evalResult = await locator.locator.evaluate(async (element, expr) => {
          const value = eval(`(${expr})`);
          const isFunction = typeof value === 'function';
          const result = await (isFunction ? value(element) : value);
```
likely benign LLM, confidence 0.70 Evaluates a caller-supplied expression inside a page context for an evaluate tool.
Reasoning
This is a browser-automation evaluate tool that intentionally runs caller-supplied JavaScript expressions in the page. The eval is the tool's purpose, not hidden obfuscation, but it is real arbitrary code execution, so it is worth noting rather than dismissing.
info ~~critical~~ → info by review dynamic-execution packages/playwright-core/src/tools/backend/evaluate.ts:57:25

`eval` called with a non-literal expression (ast pass, confidence 0.90)
```
        evalResult = await tab.page.evaluate(async expr => {
          const value = eval(`(${expr})`);
          const isFunction = typeof value === 'function';
          const result = await (isFunction ? value() : value);
```
likely benign LLM, confidence 0.70 Evaluates a caller-supplied expression in the page for a page-level evaluate tool.
Reasoning
Same design as the locator variant: a page-evaluate tool that executes the caller's expression by design. Intentional code execution in an automation tool, not a hidden payload.
info ~~warn~~ → info by review dynamic-import packages/playwright-core/src/tools/cli-client/program.ts:78:16

`require` called with a non-literal specifier (ast pass, confidence 0.60)
```
  const clientInfo = createClientInfo();
  const help = require(libPath('tools', 'cli-client', 'help.json'));

  const argv = process.argv.slice(2);
```
dismissed LLM, confidence 0.85 Loads a bundled help.json via a path helper with fixed segments.
Reasoning
The require argument is libPath('tools','cli-client','help.json') with literal segments, so it loads a bundled JSON help file. The AST rule flags any non-literal specifier, but this one is effectively fixed. No execution of fetched or decoded content appears.
info ~~warn~~ → info by review dynamic-import packages/playwright-core/src/tools/utils/connect.ts:21:14

`require` called with a non-literal specifier (ast pass, confidence 0.60)
```
export async function connectToBrowserAcrossVersions(descriptor: BrowserDescriptor): Promise<playwright.Browser> {
  const pw = require(descriptor.playwrightLib);
  const browserType = pw[descriptor.browser.browserName] as playwright.BrowserType;
  return await browserType.connect(descriptorEndpoint(descriptor));
```
likely benign LLM, confidence 0.70 Dynamically requires a Playwright library chosen by a descriptor to connect to a browser of a matching version.
Reasoning
The require target comes from descriptor.playwrightLib and the selected browser type is then used to connect. This matches a cross-version Playwright connection utility. The module path is taken from a descriptor, so if that descriptor could be attacker-controlled it would be a code-loading risk, but the snippet shows only a legitimate connect pattern.

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.0.0
git clone https://github.com/microsoft/playwright playwright && cd playwright
git checkout 034f230cc68b286055186f4d9783188536f2f3cf
disclude scan --severity info --diff a038fe7e0eb955ef41db53d40a859ce487889b6d packages/playwright-core