lib: fix phantom EACCES on spawn in some environments

lib/internal/child_process.js

@@ -38,6 +38,8 @@ const {
 const EventEmitter = require('events');
 const net = require('net');
 const dgram = require('dgram');
+const fs = require('fs');
+const path = require('path');
 const inspect = require('internal/util/inspect').inspect;
 const assert = require('internal/assert');
 
@@ -73,6 +75,32 @@ const {
  UV_ESRCH,
 } = internalBinding('uv');
 
+function verifyENOENT(file, envPairs) {
+ if (file === '.' || file.includes(path.sep)) return false;
+ let envPath;
+ if (envPairs) {
+ for (let i = 0; i < envPairs.length; i++) {
+ const pair = envPairs[i];
+ if (pair.startsWith('PATH=')) {
+ envPath = pair.slice(5);
+ break;
+ }
+ }
+ }
+ envPath ||= process.env.PATH;
+ if (!envPath) return false;
+ const paths = envPath.split(path.delimiter);
+ for (let i = 0; i < paths.length; i++) {
+ const p = paths[i];
+ if (!p) continue;
+ const fullPath = path.resolve(p, file);
+ if (fs.existsSync(fullPath)) {
+ return false;
+ }
+ }
+ return true;
+}
+
 const { SocketListSend, SocketListReceive } = SocketList;
 
 // Lazy loaded for startup performance and to allow monkey patching of
@@ -394,8 +422,9 @@ ChildProcess.prototype.spawn = function spawn(options) {
 
  const err = this._handle.spawn(options);
 
- // Run-time errors should emit an error, not throw an exception.
- if (err === UV_EACCES ||
+ if (err === UV_EACCES && verifyENOENT(this.spawnfile, options.envPairs)) {
+ process.nextTick(onErrorNT, this, UV_ENOENT);
+ } else if (err === UV_EACCES ||
  err === UV_EAGAIN ||
  err === UV_EMFILE ||
  err === UV_ENFILE ||
@@ -1088,6 +1117,10 @@ function maybeClose(subprocess) {
 function spawnSync(options) {
  const result = spawn_sync.spawn(options);
 
+ if (result.error === UV_EACCES && verifyENOENT(options.file, options.envPairs)) {
+ result.error = UV_ENOENT;
+ }
+
  if (result.output && options.encoding && options.encoding !== 'buffer') {
  for (let i = 0; i < result.output.length; i++) {
  if (!result.output[i])

test/parallel/test-child-process-spawn-path-access.js

@@ -0,0 +1,105 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Scenario: PATH contains directories that are inaccessible or are actually files.
+// The system spawn (execvp) might return EACCES in these cases on some platforms.
+// We want to ensure Node.js consistently reports ENOENT if the command is truly missing.
+
+const noPermDir = path.join(tmpdir.path, 'no-perm-dir');
+fs.mkdirSync(noPermDir);
+
+const fileInPath = path.join(tmpdir.path, 'file-in-path');
+fs.writeFileSync(fileInPath, '');
+
+if (!common.isWindows) {
+ try {
+ fs.chmodSync(noPermDir, '000');
+ } catch (e) {
+ // If we can't chmod (e.g. root or weird fs), skip the permission part of the test
+ // but keep the structure.
+ console.log('# Skipped chmod 000 on no-perm-dir due to error:', e.message);
+ }
+}
+
+// Ensure cleanup restores permissions so tmpdir can be removed
+process.prependListener('exit', () => {
+ if (!common.isWindows && fs.existsSync(noPermDir)) {
+ try {
+ fs.chmodSync(noPermDir, '777');
+ } catch {
+ // Ignore cleanup errors during exit
+ }
+ }
+});
+
+const env = { ...process.env };
+const sep = path.delimiter;
+
+// Prepend the problematic entries to PATH
+env.PATH = `${noPermDir}${sep}${fileInPath}${sep}${env.PATH}`;
+
+const command = 'command-that-does-not-exist-at-all-' + Date.now();
+
+const child = cp.spawn(command, { env });
+
+child.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ assert.strictEqual(err.syscall, `spawn ${command}`);
+}));
+
+// Also test sync
+try {
+ cp.spawnSync(command, { env });
+} catch (err) {
+ assert.strictEqual(err.code, 'ENOENT');
+}
+
+// Case: File exists but is not executable. Should NOT be normalized to ENOENT.
+if (!common.isWindows) {
+ const nonExecFile = path.join(tmpdir.path, 'non-executable');
+ fs.writeFileSync(nonExecFile, 'echo "should not run"');
+ fs.chmodSync(nonExecFile, '644');
+
+ const env2 = { ...process.env, PATH: tmpdir.path };
+ const child2 = cp.spawn('non-executable', { env: env2 });
+ child2.on('error', common.mustCall((err) => {
+ // It should stay EACCES because the file actually exists
+ assert.strictEqual(err.code, 'EACCES');
+ }));
+
+ // Also test empty PATH entry
+ const env3 = { ...process.env, PATH: `${path.delimiter}${env.PATH}` };
+ const child3 = cp.spawn(command, { env: env3 });
+ child3.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+}
+
+// Case: No PATH in envPairs
+const env4 = { ...process.env };
+delete env4.PATH;
+const child4 = cp.spawn(command, { env: env4 });
+child4.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+}));
+
+// Case: envPath ||= process.env.PATH (no env passed)
+if (!common.isWindows) {
+ const oldPath = process.env.PATH;
+ process.env.PATH = `${noPermDir}${path.delimiter}${oldPath}`;
+ try {
+ const child5 = cp.spawn(command);
+ child5.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+ } finally {
+ process.env.PATH = oldPath;
+ }
+}

lib/internal/child_process.js

@@ -38,6 +38,8 @@ const {
 const EventEmitter = require('events');
 const net = require('net');
 const dgram = require('dgram');
+const fs = require('fs');
+const path = require('path');
 const inspect = require('internal/util/inspect').inspect;
 const assert = require('internal/assert');
 
@@ -73,6 +75,32 @@ const {
  UV_ESRCH,
 } = internalBinding('uv');
 
+function verifyENOENT(file, envPairs) {
+ if (file === '.' || file.includes(path.sep)) return false;
+ let envPath;
+ if (envPairs) {
+ for (let i = 0; i < envPairs.length; i++) {
+ const pair = envPairs[i];
+ if (pair.startsWith('PATH=')) {
+ envPath = pair.slice(5);
+ break;
+ }
+ }
+ }
+ envPath ||= process.env.PATH;
+ if (!envPath) return false;
+ const paths = envPath.split(path.delimiter);
+ for (let i = 0; i < paths.length; i++) {
+ const p = paths[i];
+ if (!p) continue;
+ const fullPath = path.resolve(p, file);
+ if (fs.existsSync(fullPath)) {
+ return false;
+ }
+ }
+ return true;
+}
+
 const { SocketListSend, SocketListReceive } = SocketList;
 
 // Lazy loaded for startup performance and to allow monkey patching of
@@ -394,8 +422,9 @@ ChildProcess.prototype.spawn = function spawn(options) {
 
  const err = this._handle.spawn(options);
 
- // Run-time errors should emit an error, not throw an exception.
- if (err === UV_EACCES ||
+ if (err === UV_EACCES && verifyENOENT(this.spawnfile, options.envPairs)) {
+ process.nextTick(onErrorNT, this, UV_ENOENT);
+ } else if (err === UV_EACCES ||
  err === UV_EAGAIN ||
  err === UV_EMFILE ||
  err === UV_ENFILE ||
@@ -1088,6 +1117,10 @@ function maybeClose(subprocess) {
 function spawnSync(options) {
  const result = spawn_sync.spawn(options);
 
+ if (result.error === UV_EACCES && verifyENOENT(options.file, options.envPairs)) {
+ result.error = UV_ENOENT;
+ }
+
  if (result.output && options.encoding && options.encoding !== 'buffer') {
  for (let i = 0; i < result.output.length; i++) {
  if (!result.output[i])

test/parallel/test-child-process-spawn-path-access.js

@@ -0,0 +1,105 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Scenario: PATH contains directories that are inaccessible or are actually files.
+// The system spawn (execvp) might return EACCES in these cases on some platforms.
+// We want to ensure Node.js consistently reports ENOENT if the command is truly missing.
+
+const noPermDir = path.join(tmpdir.path, 'no-perm-dir');
+fs.mkdirSync(noPermDir);
+
+const fileInPath = path.join(tmpdir.path, 'file-in-path');
+fs.writeFileSync(fileInPath, '');
+
+if (!common.isWindows) {
+ try {
+ fs.chmodSync(noPermDir, '000');
+ } catch (e) {
+ // If we can't chmod (e.g. root or weird fs), skip the permission part of the test
+ // but keep the structure.
+ console.log('# Skipped chmod 000 on no-perm-dir due to error:', e.message);
+ }
+}
+
+// Ensure cleanup restores permissions so tmpdir can be removed
+process.prependListener('exit', () => {
+ if (!common.isWindows && fs.existsSync(noPermDir)) {
+ try {
+ fs.chmodSync(noPermDir, '777');
+ } catch {
+ // Ignore cleanup errors during exit
+ }
+ }
+});
+
+const env = { ...process.env };
+const sep = path.delimiter;
+
+// Prepend the problematic entries to PATH
+env.PATH = `${noPermDir}${sep}${fileInPath}${sep}${env.PATH}`;
+
+const command = 'command-that-does-not-exist-at-all-' + Date.now();
+
+const child = cp.spawn(command, { env });
+
+child.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ assert.strictEqual(err.syscall, `spawn ${command}`);
+}));
+
+// Also test sync
+try {
+ cp.spawnSync(command, { env });
+} catch (err) {
+ assert.strictEqual(err.code, 'ENOENT');
+}
+
+// Case: File exists but is not executable. Should NOT be normalized to ENOENT.
+if (!common.isWindows) {
+ const nonExecFile = path.join(tmpdir.path, 'non-executable');
+ fs.writeFileSync(nonExecFile, 'echo "should not run"');
+ fs.chmodSync(nonExecFile, '644');
+
+ const env2 = { ...process.env, PATH: tmpdir.path };
+ const child2 = cp.spawn('non-executable', { env: env2 });
+ child2.on('error', common.mustCall((err) => {
+ // It should stay EACCES because the file actually exists
+ assert.strictEqual(err.code, 'EACCES');
+ }));
+
+ // Also test empty PATH entry
+ const env3 = { ...process.env, PATH: `${path.delimiter}${env.PATH}` };
+ const child3 = cp.spawn(command, { env: env3 });
+ child3.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+}
+
+// Case: No PATH in envPairs
+const env4 = { ...process.env };
+delete env4.PATH;
+const child4 = cp.spawn(command, { env: env4 });
+child4.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+}));
+
+// Case: envPath ||= process.env.PATH (no env passed)
+if (!common.isWindows) {
+ const oldPath = process.env.PATH;
+ process.env.PATH = `${noPermDir}${path.delimiter}${oldPath}`;
+ try {
+ const child5 = cp.spawn(command);
+ child5.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+ } finally {
+ process.env.PATH = oldPath;
+ }
+}

lib/internal/child_process.js

@@ -38,6 +38,8 @@ const {
 const EventEmitter = require('events');
 const net = require('net');
 const dgram = require('dgram');
+const fs = require('fs');
+const path = require('path');
 const inspect = require('internal/util/inspect').inspect;
 const assert = require('internal/assert');
 
@@ -73,6 +75,32 @@ const {
  UV_ESRCH,
 } = internalBinding('uv');
 
+function verifyENOENT(file, envPairs) {
+ if (file === '.' || file.includes(path.sep)) return false;
+ let envPath;
+ if (envPairs) {
+ for (let i = 0; i < envPairs.length; i++) {
+ const pair = envPairs[i];
+ if (pair.startsWith('PATH=')) {
+ envPath = pair.slice(5);
+ break;
+ }
+ }
+ }
+ envPath ||= process.env.PATH;
+ if (!envPath) return false;
+ const paths = envPath.split(path.delimiter);
+ for (let i = 0; i < paths.length; i++) {
+ const p = paths[i];
+ if (!p) continue;
+ const fullPath = path.resolve(p, file);
+ if (fs.existsSync(fullPath)) {
+ return false;
+ }
+ }
+ return true;
+}
+
 const { SocketListSend, SocketListReceive } = SocketList;
 
 // Lazy loaded for startup performance and to allow monkey patching of
@@ -394,8 +422,9 @@ ChildProcess.prototype.spawn = function spawn(options) {
 
  const err = this._handle.spawn(options);
 
- // Run-time errors should emit an error, not throw an exception.
- if (err === UV_EACCES ||
+ if (err === UV_EACCES && verifyENOENT(this.spawnfile, options.envPairs)) {
+ process.nextTick(onErrorNT, this, UV_ENOENT);
+ } else if (err === UV_EACCES ||
  err === UV_EAGAIN ||
  err === UV_EMFILE ||
  err === UV_ENFILE ||
@@ -1088,6 +1117,10 @@ function maybeClose(subprocess) {
 function spawnSync(options) {
  const result = spawn_sync.spawn(options);
 
+ if (result.error === UV_EACCES && verifyENOENT(options.file, options.envPairs)) {
+ result.error = UV_ENOENT;
+ }
+
  if (result.output && options.encoding && options.encoding !== 'buffer') {
  for (let i = 0; i < result.output.length; i++) {
  if (!result.output[i])

test/parallel/test-child-process-spawn-path-access.js

@@ -0,0 +1,105 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Scenario: PATH contains directories that are inaccessible or are actually files.
+// The system spawn (execvp) might return EACCES in these cases on some platforms.
+// We want to ensure Node.js consistently reports ENOENT if the command is truly missing.
+
+const noPermDir = path.join(tmpdir.path, 'no-perm-dir');
+fs.mkdirSync(noPermDir);
+
+const fileInPath = path.join(tmpdir.path, 'file-in-path');
+fs.writeFileSync(fileInPath, '');
+
+if (!common.isWindows) {
+ try {
+ fs.chmodSync(noPermDir, '000');
+ } catch (e) {
+ // If we can't chmod (e.g. root or weird fs), skip the permission part of the test
+ // but keep the structure.
+ console.log('# Skipped chmod 000 on no-perm-dir due to error:', e.message);
+ }
+}
+
+// Ensure cleanup restores permissions so tmpdir can be removed
+process.prependListener('exit', () => {
+ if (!common.isWindows && fs.existsSync(noPermDir)) {
+ try {
+ fs.chmodSync(noPermDir, '777');
+ } catch {
+ // Ignore cleanup errors during exit
+ }
+ }
+});
+
+const env = { ...process.env };
+const sep = path.delimiter;
+
+// Prepend the problematic entries to PATH
+env.PATH = `${noPermDir}${sep}${fileInPath}${sep}${env.PATH}`;
+
+const command = 'command-that-does-not-exist-at-all-' + Date.now();
+
+const child = cp.spawn(command, { env });
+
+child.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ assert.strictEqual(err.syscall, `spawn ${command}`);
+}));
+
+// Also test sync
+try {
+ cp.spawnSync(command, { env });
+} catch (err) {
+ assert.strictEqual(err.code, 'ENOENT');
+}
+
+// Case: File exists but is not executable. Should NOT be normalized to ENOENT.
+if (!common.isWindows) {
+ const nonExecFile = path.join(tmpdir.path, 'non-executable');
+ fs.writeFileSync(nonExecFile, 'echo "should not run"');
+ fs.chmodSync(nonExecFile, '644');
+
+ const env2 = { ...process.env, PATH: tmpdir.path };
+ const child2 = cp.spawn('non-executable', { env: env2 });
+ child2.on('error', common.mustCall((err) => {
+ // It should stay EACCES because the file actually exists
+ assert.strictEqual(err.code, 'EACCES');
+ }));
+
+ // Also test empty PATH entry
+ const env3 = { ...process.env, PATH: `${path.delimiter}${env.PATH}` };
+ const child3 = cp.spawn(command, { env: env3 });
+ child3.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+}
+
+// Case: No PATH in envPairs
+const env4 = { ...process.env };
+delete env4.PATH;
+const child4 = cp.spawn(command, { env: env4 });
+child4.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+}));
+
+// Case: envPath ||= process.env.PATH (no env passed)
+if (!common.isWindows) {
+ const oldPath = process.env.PATH;
+ process.env.PATH = `${noPermDir}${path.delimiter}${oldPath}`;
+ try {
+ const child5 = cp.spawn(command);
+ child5.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+ } finally {
+ process.env.PATH = oldPath;
+ }
+}

lib/internal/child_process.js

@@ -38,6 +38,8 @@ const {
 const EventEmitter = require('events');
 const net = require('net');
 const dgram = require('dgram');
+const fs = require('fs');
+const path = require('path');
 const inspect = require('internal/util/inspect').inspect;
 const assert = require('internal/assert');
 
@@ -73,6 +75,32 @@ const {
  UV_ESRCH,
 } = internalBinding('uv');
 
+function verifyENOENT(file, envPairs) {
+ if (file === '.' || file.includes(path.sep)) return false;
+ let envPath;
+ if (envPairs) {
+ for (let i = 0; i < envPairs.length; i++) {
+ const pair = envPairs[i];
+ if (pair.startsWith('PATH=')) {
+ envPath = pair.slice(5);
+ break;
+ }
+ }
+ }
+ envPath ||= process.env.PATH;
+ if (!envPath) return false;
+ const paths = envPath.split(path.delimiter);
+ for (let i = 0; i < paths.length; i++) {
+ const p = paths[i];
+ if (!p) continue;
+ const fullPath = path.resolve(p, file);
+ if (fs.existsSync(fullPath)) {
+ return false;
+ }
+ }
+ return true;
+}
+
 const { SocketListSend, SocketListReceive } = SocketList;
 
 // Lazy loaded for startup performance and to allow monkey patching of
@@ -394,8 +422,9 @@ ChildProcess.prototype.spawn = function spawn(options) {
 
  const err = this._handle.spawn(options);
 
- // Run-time errors should emit an error, not throw an exception.
- if (err === UV_EACCES ||
+ if (err === UV_EACCES && verifyENOENT(this.spawnfile, options.envPairs)) {
+ process.nextTick(onErrorNT, this, UV_ENOENT);
+ } else if (err === UV_EACCES ||
  err === UV_EAGAIN ||
  err === UV_EMFILE ||
  err === UV_ENFILE ||
@@ -1088,6 +1117,10 @@ function maybeClose(subprocess) {
 function spawnSync(options) {
  const result = spawn_sync.spawn(options);
 
+ if (result.error === UV_EACCES && verifyENOENT(options.file, options.envPairs)) {
+ result.error = UV_ENOENT;
+ }
+
  if (result.output && options.encoding && options.encoding !== 'buffer') {
  for (let i = 0; i < result.output.length; i++) {
  if (!result.output[i])

test/parallel/test-child-process-spawn-path-access.js

@@ -0,0 +1,105 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Scenario: PATH contains directories that are inaccessible or are actually files.
+// The system spawn (execvp) might return EACCES in these cases on some platforms.
+// We want to ensure Node.js consistently reports ENOENT if the command is truly missing.
+
+const noPermDir = path.join(tmpdir.path, 'no-perm-dir');
+fs.mkdirSync(noPermDir);
+
+const fileInPath = path.join(tmpdir.path, 'file-in-path');
+fs.writeFileSync(fileInPath, '');
+
+if (!common.isWindows) {
+ try {
+ fs.chmodSync(noPermDir, '000');
+ } catch (e) {
+ // If we can't chmod (e.g. root or weird fs), skip the permission part of the test
+ // but keep the structure.
+ console.log('# Skipped chmod 000 on no-perm-dir due to error:', e.message);
+ }
+}
+
+// Ensure cleanup restores permissions so tmpdir can be removed
+process.prependListener('exit', () => {
+ if (!common.isWindows && fs.existsSync(noPermDir)) {
+ try {
+ fs.chmodSync(noPermDir, '777');
+ } catch {
+ // Ignore cleanup errors during exit
+ }
+ }
+});
+
+const env = { ...process.env };
+const sep = path.delimiter;
+
+// Prepend the problematic entries to PATH
+env.PATH = `${noPermDir}${sep}${fileInPath}${sep}${env.PATH}`;
+
+const command = 'command-that-does-not-exist-at-all-' + Date.now();
+
+const child = cp.spawn(command, { env });
+
+child.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ assert.strictEqual(err.syscall, `spawn ${command}`);
+}));
+
+// Also test sync
+try {
+ cp.spawnSync(command, { env });
+} catch (err) {
+ assert.strictEqual(err.code, 'ENOENT');
+}
+
+// Case: File exists but is not executable. Should NOT be normalized to ENOENT.
+if (!common.isWindows) {
+ const nonExecFile = path.join(tmpdir.path, 'non-executable');
+ fs.writeFileSync(nonExecFile, 'echo "should not run"');
+ fs.chmodSync(nonExecFile, '644');
+
+ const env2 = { ...process.env, PATH: tmpdir.path };
+ const child2 = cp.spawn('non-executable', { env: env2 });
+ child2.on('error', common.mustCall((err) => {
+ // It should stay EACCES because the file actually exists
+ assert.strictEqual(err.code, 'EACCES');
+ }));
+
+ // Also test empty PATH entry
+ const env3 = { ...process.env, PATH: `${path.delimiter}${env.PATH}` };
+ const child3 = cp.spawn(command, { env: env3 });
+ child3.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+}
+
+// Case: No PATH in envPairs
+const env4 = { ...process.env };
+delete env4.PATH;
+const child4 = cp.spawn(command, { env: env4 });
+child4.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+}));
+
+// Case: envPath ||= process.env.PATH (no env passed)
+if (!common.isWindows) {
+ const oldPath = process.env.PATH;
+ process.env.PATH = `${noPermDir}${path.delimiter}${oldPath}`;
+ try {
+ const child5 = cp.spawn(command);
+ child5.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+ } finally {
+ process.env.PATH = oldPath;
+ }
+}

lib/internal/child_process.js

@@ -38,6 +38,8 @@ const {
 const EventEmitter = require('events');
 const net = require('net');
 const dgram = require('dgram');
+const fs = require('fs');
+const path = require('path');
 const inspect = require('internal/util/inspect').inspect;
 const assert = require('internal/assert');
 
@@ -73,6 +75,32 @@ const {
  UV_ESRCH,
 } = internalBinding('uv');
 
+function verifyENOENT(file, envPairs) {
+ if (file === '.' || file.includes(path.sep)) return false;
+ let envPath;
+ if (envPairs) {
+ for (let i = 0; i < envPairs.length; i++) {
+ const pair = envPairs[i];
+ if (pair.startsWith('PATH=')) {
+ envPath = pair.slice(5);
+ break;
+ }
+ }
+ }
+ envPath ||= process.env.PATH;
+ if (!envPath) return false;
+ const paths = envPath.split(path.delimiter);
+ for (let i = 0; i < paths.length; i++) {
+ const p = paths[i];
+ if (!p) continue;
+ const fullPath = path.resolve(p, file);
+ if (fs.existsSync(fullPath)) {
+ return false;
+ }
+ }
+ return true;
+}
+
 const { SocketListSend, SocketListReceive } = SocketList;
 
 // Lazy loaded for startup performance and to allow monkey patching of
@@ -394,8 +422,9 @@ ChildProcess.prototype.spawn = function spawn(options) {
 
  const err = this._handle.spawn(options);
 
- // Run-time errors should emit an error, not throw an exception.
- if (err === UV_EACCES ||
+ if (err === UV_EACCES && verifyENOENT(this.spawnfile, options.envPairs)) {
+ process.nextTick(onErrorNT, this, UV_ENOENT);
+ } else if (err === UV_EACCES ||
  err === UV_EAGAIN ||
  err === UV_EMFILE ||
  err === UV_ENFILE ||
@@ -1088,6 +1117,10 @@ function maybeClose(subprocess) {
 function spawnSync(options) {
  const result = spawn_sync.spawn(options);
 
+ if (result.error === UV_EACCES && verifyENOENT(options.file, options.envPairs)) {
+ result.error = UV_ENOENT;
+ }
+
  if (result.output && options.encoding && options.encoding !== 'buffer') {
  for (let i = 0; i < result.output.length; i++) {
  if (!result.output[i])

test/parallel/test-child-process-spawn-path-access.js

@@ -0,0 +1,105 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Scenario: PATH contains directories that are inaccessible or are actually files.
+// The system spawn (execvp) might return EACCES in these cases on some platforms.
+// We want to ensure Node.js consistently reports ENOENT if the command is truly missing.
+
+const noPermDir = path.join(tmpdir.path, 'no-perm-dir');
+fs.mkdirSync(noPermDir);
+
+const fileInPath = path.join(tmpdir.path, 'file-in-path');
+fs.writeFileSync(fileInPath, '');
+
+if (!common.isWindows) {
+ try {
+ fs.chmodSync(noPermDir, '000');
+ } catch (e) {
+ // If we can't chmod (e.g. root or weird fs), skip the permission part of the test
+ // but keep the structure.
+ console.log('# Skipped chmod 000 on no-perm-dir due to error:', e.message);
+ }
+}
+
+// Ensure cleanup restores permissions so tmpdir can be removed
+process.prependListener('exit', () => {
+ if (!common.isWindows && fs.existsSync(noPermDir)) {
+ try {
+ fs.chmodSync(noPermDir, '777');
+ } catch {
+ // Ignore cleanup errors during exit
+ }
+ }
+});
+
+const env = { ...process.env };
+const sep = path.delimiter;
+
+// Prepend the problematic entries to PATH
+env.PATH = `${noPermDir}${sep}${fileInPath}${sep}${env.PATH}`;
+
+const command = 'command-that-does-not-exist-at-all-' + Date.now();
+
+const child = cp.spawn(command, { env });
+
+child.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ assert.strictEqual(err.syscall, `spawn ${command}`);
+}));
+
+// Also test sync
+try {
+ cp.spawnSync(command, { env });
+} catch (err) {
+ assert.strictEqual(err.code, 'ENOENT');
+}
+
+// Case: File exists but is not executable. Should NOT be normalized to ENOENT.
+if (!common.isWindows) {
+ const nonExecFile = path.join(tmpdir.path, 'non-executable');
+ fs.writeFileSync(nonExecFile, 'echo "should not run"');
+ fs.chmodSync(nonExecFile, '644');
+
+ const env2 = { ...process.env, PATH: tmpdir.path };
+ const child2 = cp.spawn('non-executable', { env: env2 });
+ child2.on('error', common.mustCall((err) => {
+ // It should stay EACCES because the file actually exists
+ assert.strictEqual(err.code, 'EACCES');
+ }));
+
+ // Also test empty PATH entry
+ const env3 = { ...process.env, PATH: `${path.delimiter}${env.PATH}` };
+ const child3 = cp.spawn(command, { env: env3 });
+ child3.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+}
+
+// Case: No PATH in envPairs
+const env4 = { ...process.env };
+delete env4.PATH;
+const child4 = cp.spawn(command, { env: env4 });
+child4.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+}));
+
+// Case: envPath ||= process.env.PATH (no env passed)
+if (!common.isWindows) {
+ const oldPath = process.env.PATH;
+ process.env.PATH = `${noPermDir}${path.delimiter}${oldPath}`;
+ try {
+ const child5 = cp.spawn(command);
+ child5.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+ } finally {
+ process.env.PATH = oldPath;
+ }
+}

lib/internal/child_process.js

@@ -38,6 +38,8 @@ const {
 const EventEmitter = require('events');
 const net = require('net');
 const dgram = require('dgram');
+const fs = require('fs');
+const path = require('path');
 const inspect = require('internal/util/inspect').inspect;
 const assert = require('internal/assert');
 
@@ -73,6 +75,32 @@ const {
  UV_ESRCH,
 } = internalBinding('uv');
 
+function verifyENOENT(file, envPairs) {
+ if (file === '.' || file.includes(path.sep)) return false;
+ let envPath;
+ if (envPairs) {
+ for (let i = 0; i < envPairs.length; i++) {
+ const pair = envPairs[i];
+ if (pair.startsWith('PATH=')) {
+ envPath = pair.slice(5);
+ break;
+ }
+ }
+ }
+ envPath ||= process.env.PATH;
+ if (!envPath) return false;
+ const paths = envPath.split(path.delimiter);
+ for (let i = 0; i < paths.length; i++) {
+ const p = paths[i];
+ if (!p) continue;
+ const fullPath = path.resolve(p, file);
+ if (fs.existsSync(fullPath)) {
+ return false;
+ }
+ }
+ return true;
+}
+
 const { SocketListSend, SocketListReceive } = SocketList;
 
 // Lazy loaded for startup performance and to allow monkey patching of
@@ -394,8 +422,9 @@ ChildProcess.prototype.spawn = function spawn(options) {
 
  const err = this._handle.spawn(options);
 
- // Run-time errors should emit an error, not throw an exception.
- if (err === UV_EACCES ||
+ if (err === UV_EACCES && verifyENOENT(this.spawnfile, options.envPairs)) {
+ process.nextTick(onErrorNT, this, UV_ENOENT);
+ } else if (err === UV_EACCES ||
  err === UV_EAGAIN ||
  err === UV_EMFILE ||
  err === UV_ENFILE ||
@@ -1088,6 +1117,10 @@ function maybeClose(subprocess) {
 function spawnSync(options) {
  const result = spawn_sync.spawn(options);
 
+ if (result.error === UV_EACCES && verifyENOENT(options.file, options.envPairs)) {
+ result.error = UV_ENOENT;
+ }
+
  if (result.output && options.encoding && options.encoding !== 'buffer') {
  for (let i = 0; i < result.output.length; i++) {
  if (!result.output[i])

test/parallel/test-child-process-spawn-path-access.js

@@ -0,0 +1,105 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Scenario: PATH contains directories that are inaccessible or are actually files.
+// The system spawn (execvp) might return EACCES in these cases on some platforms.
+// We want to ensure Node.js consistently reports ENOENT if the command is truly missing.
+
+const noPermDir = path.join(tmpdir.path, 'no-perm-dir');
+fs.mkdirSync(noPermDir);
+
+const fileInPath = path.join(tmpdir.path, 'file-in-path');
+fs.writeFileSync(fileInPath, '');
+
+if (!common.isWindows) {
+ try {
+ fs.chmodSync(noPermDir, '000');
+ } catch (e) {
+ // If we can't chmod (e.g. root or weird fs), skip the permission part of the test
+ // but keep the structure.
+ console.log('# Skipped chmod 000 on no-perm-dir due to error:', e.message);
+ }
+}
+
+// Ensure cleanup restores permissions so tmpdir can be removed
+process.prependListener('exit', () => {
+ if (!common.isWindows && fs.existsSync(noPermDir)) {
+ try {
+ fs.chmodSync(noPermDir, '777');
+ } catch {
+ // Ignore cleanup errors during exit
+ }
+ }
+});
+
+const env = { ...process.env };
+const sep = path.delimiter;
+
+// Prepend the problematic entries to PATH
+env.PATH = `${noPermDir}${sep}${fileInPath}${sep}${env.PATH}`;
+
+const command = 'command-that-does-not-exist-at-all-' + Date.now();
+
+const child = cp.spawn(command, { env });
+
+child.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ assert.strictEqual(err.syscall, `spawn ${command}`);
+}));
+
+// Also test sync
+try {
+ cp.spawnSync(command, { env });
+} catch (err) {
+ assert.strictEqual(err.code, 'ENOENT');
+}
+
+// Case: File exists but is not executable. Should NOT be normalized to ENOENT.
+if (!common.isWindows) {
+ const nonExecFile = path.join(tmpdir.path, 'non-executable');
+ fs.writeFileSync(nonExecFile, 'echo "should not run"');
+ fs.chmodSync(nonExecFile, '644');
+
+ const env2 = { ...process.env, PATH: tmpdir.path };
+ const child2 = cp.spawn('non-executable', { env: env2 });
+ child2.on('error', common.mustCall((err) => {
+ // It should stay EACCES because the file actually exists
+ assert.strictEqual(err.code, 'EACCES');
+ }));
+
+ // Also test empty PATH entry
+ const env3 = { ...process.env, PATH: `${path.delimiter}${env.PATH}` };
+ const child3 = cp.spawn(command, { env: env3 });
+ child3.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+}
+
+// Case: No PATH in envPairs
+const env4 = { ...process.env };
+delete env4.PATH;
+const child4 = cp.spawn(command, { env: env4 });
+child4.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+}));
+
+// Case: envPath ||= process.env.PATH (no env passed)
+if (!common.isWindows) {
+ const oldPath = process.env.PATH;
+ process.env.PATH = `${noPermDir}${path.delimiter}${oldPath}`;
+ try {
+ const child5 = cp.spawn(command);
+ child5.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+ } finally {
+ process.env.PATH = oldPath;
+ }
+}

lib/internal/child_process.js

@@ -38,6 +38,8 @@ const {
 const EventEmitter = require('events');
 const net = require('net');
 const dgram = require('dgram');
+const fs = require('fs');
+const path = require('path');
 const inspect = require('internal/util/inspect').inspect;
 const assert = require('internal/assert');
 
@@ -73,6 +75,32 @@ const {
  UV_ESRCH,
 } = internalBinding('uv');
 
+function verifyENOENT(file, envPairs) {
+ if (file === '.' || file.includes(path.sep)) return false;
+ let envPath;
+ if (envPairs) {
+ for (let i = 0; i < envPairs.length; i++) {
+ const pair = envPairs[i];
+ if (pair.startsWith('PATH=')) {
+ envPath = pair.slice(5);
+ break;
+ }
+ }
+ }
+ envPath ||= process.env.PATH;
+ if (!envPath) return false;
+ const paths = envPath.split(path.delimiter);
+ for (let i = 0; i < paths.length; i++) {
+ const p = paths[i];
+ if (!p) continue;
+ const fullPath = path.resolve(p, file);
+ if (fs.existsSync(fullPath)) {
+ return false;
+ }
+ }
+ return true;
+}
+
 const { SocketListSend, SocketListReceive } = SocketList;
 
 // Lazy loaded for startup performance and to allow monkey patching of
@@ -394,8 +422,9 @@ ChildProcess.prototype.spawn = function spawn(options) {
 
  const err = this._handle.spawn(options);
 
- // Run-time errors should emit an error, not throw an exception.
- if (err === UV_EACCES ||
+ if (err === UV_EACCES && verifyENOENT(this.spawnfile, options.envPairs)) {
+ process.nextTick(onErrorNT, this, UV_ENOENT);
+ } else if (err === UV_EACCES ||
  err === UV_EAGAIN ||
  err === UV_EMFILE ||
  err === UV_ENFILE ||
@@ -1088,6 +1117,10 @@ function maybeClose(subprocess) {
 function spawnSync(options) {
  const result = spawn_sync.spawn(options);
 
+ if (result.error === UV_EACCES && verifyENOENT(options.file, options.envPairs)) {
+ result.error = UV_ENOENT;
+ }
+
  if (result.output && options.encoding && options.encoding !== 'buffer') {
  for (let i = 0; i < result.output.length; i++) {
  if (!result.output[i])

test/parallel/test-child-process-spawn-path-access.js

@@ -0,0 +1,105 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Scenario: PATH contains directories that are inaccessible or are actually files.
+// The system spawn (execvp) might return EACCES in these cases on some platforms.
+// We want to ensure Node.js consistently reports ENOENT if the command is truly missing.
+
+const noPermDir = path.join(tmpdir.path, 'no-perm-dir');
+fs.mkdirSync(noPermDir);
+
+const fileInPath = path.join(tmpdir.path, 'file-in-path');
+fs.writeFileSync(fileInPath, '');
+
+if (!common.isWindows) {
+ try {
+ fs.chmodSync(noPermDir, '000');
+ } catch (e) {
+ // If we can't chmod (e.g. root or weird fs), skip the permission part of the test
+ // but keep the structure.
+ console.log('# Skipped chmod 000 on no-perm-dir due to error:', e.message);
+ }
+}
+
+// Ensure cleanup restores permissions so tmpdir can be removed
+process.prependListener('exit', () => {
+ if (!common.isWindows && fs.existsSync(noPermDir)) {
+ try {
+ fs.chmodSync(noPermDir, '777');
+ } catch {
+ // Ignore cleanup errors during exit
+ }
+ }
+});
+
+const env = { ...process.env };
+const sep = path.delimiter;
+
+// Prepend the problematic entries to PATH
+env.PATH = `${noPermDir}${sep}${fileInPath}${sep}${env.PATH}`;
+
+const command = 'command-that-does-not-exist-at-all-' + Date.now();
+
+const child = cp.spawn(command, { env });
+
+child.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ assert.strictEqual(err.syscall, `spawn ${command}`);
+}));
+
+// Also test sync
+try {
+ cp.spawnSync(command, { env });
+} catch (err) {
+ assert.strictEqual(err.code, 'ENOENT');
+}
+
+// Case: File exists but is not executable. Should NOT be normalized to ENOENT.
+if (!common.isWindows) {
+ const nonExecFile = path.join(tmpdir.path, 'non-executable');
+ fs.writeFileSync(nonExecFile, 'echo "should not run"');
+ fs.chmodSync(nonExecFile, '644');
+
+ const env2 = { ...process.env, PATH: tmpdir.path };
+ const child2 = cp.spawn('non-executable', { env: env2 });
+ child2.on('error', common.mustCall((err) => {
+ // It should stay EACCES because the file actually exists
+ assert.strictEqual(err.code, 'EACCES');
+ }));
+
+ // Also test empty PATH entry
+ const env3 = { ...process.env, PATH: `${path.delimiter}${env.PATH}` };
+ const child3 = cp.spawn(command, { env: env3 });
+ child3.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+}
+
+// Case: No PATH in envPairs
+const env4 = { ...process.env };
+delete env4.PATH;
+const child4 = cp.spawn(command, { env: env4 });
+child4.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+}));
+
+// Case: envPath ||= process.env.PATH (no env passed)
+if (!common.isWindows) {
+ const oldPath = process.env.PATH;
+ process.env.PATH = `${noPermDir}${path.delimiter}${oldPath}`;
+ try {
+ const child5 = cp.spawn(command);
+ child5.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+ } finally {
+ process.env.PATH = oldPath;
+ }
+}

lib/internal/child_process.js

@@ -38,6 +38,8 @@ const {
 const EventEmitter = require('events');
 const net = require('net');
 const dgram = require('dgram');
+const fs = require('fs');
+const path = require('path');
 const inspect = require('internal/util/inspect').inspect;
 const assert = require('internal/assert');
 
@@ -73,6 +75,32 @@ const {
  UV_ESRCH,
 } = internalBinding('uv');
 
+function verifyENOENT(file, envPairs) {
+ if (file === '.' || file.includes(path.sep)) return false;
+ let envPath;
+ if (envPairs) {
+ for (let i = 0; i < envPairs.length; i++) {
+ const pair = envPairs[i];
+ if (pair.startsWith('PATH=')) {
+ envPath = pair.slice(5);
+ break;
+ }
+ }
+ }
+ envPath ||= process.env.PATH;
+ if (!envPath) return false;
+ const paths = envPath.split(path.delimiter);
+ for (let i = 0; i < paths.length; i++) {
+ const p = paths[i];
+ if (!p) continue;
+ const fullPath = path.resolve(p, file);
+ if (fs.existsSync(fullPath)) {
+ return false;
+ }
+ }
+ return true;
+}
+
 const { SocketListSend, SocketListReceive } = SocketList;
 
 // Lazy loaded for startup performance and to allow monkey patching of
@@ -394,8 +422,9 @@ ChildProcess.prototype.spawn = function spawn(options) {
 
  const err = this._handle.spawn(options);
 
- // Run-time errors should emit an error, not throw an exception.
- if (err === UV_EACCES ||
+ if (err === UV_EACCES && verifyENOENT(this.spawnfile, options.envPairs)) {
+ process.nextTick(onErrorNT, this, UV_ENOENT);
+ } else if (err === UV_EACCES ||
  err === UV_EAGAIN ||
  err === UV_EMFILE ||
  err === UV_ENFILE ||
@@ -1088,6 +1117,10 @@ function maybeClose(subprocess) {
 function spawnSync(options) {
  const result = spawn_sync.spawn(options);
 
+ if (result.error === UV_EACCES && verifyENOENT(options.file, options.envPairs)) {
+ result.error = UV_ENOENT;
+ }
+
  if (result.output && options.encoding && options.encoding !== 'buffer') {
  for (let i = 0; i < result.output.length; i++) {
  if (!result.output[i])

test/parallel/test-child-process-spawn-path-access.js

@@ -0,0 +1,105 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+// Scenario: PATH contains directories that are inaccessible or are actually files.
+// The system spawn (execvp) might return EACCES in these cases on some platforms.
+// We want to ensure Node.js consistently reports ENOENT if the command is truly missing.
+
+const noPermDir = path.join(tmpdir.path, 'no-perm-dir');
+fs.mkdirSync(noPermDir);
+
+const fileInPath = path.join(tmpdir.path, 'file-in-path');
+fs.writeFileSync(fileInPath, '');
+
+if (!common.isWindows) {
+ try {
+ fs.chmodSync(noPermDir, '000');
+ } catch (e) {
+ // If we can't chmod (e.g. root or weird fs), skip the permission part of the test
+ // but keep the structure.
+ console.log('# Skipped chmod 000 on no-perm-dir due to error:', e.message);
+ }
+}
+
+// Ensure cleanup restores permissions so tmpdir can be removed
+process.prependListener('exit', () => {
+ if (!common.isWindows && fs.existsSync(noPermDir)) {
+ try {
+ fs.chmodSync(noPermDir, '777');
+ } catch {
+ // Ignore cleanup errors during exit
+ }
+ }
+});
+
+const env = { ...process.env };
+const sep = path.delimiter;
+
+// Prepend the problematic entries to PATH
+env.PATH = `${noPermDir}${sep}${fileInPath}${sep}${env.PATH}`;
+
+const command = 'command-that-does-not-exist-at-all-' + Date.now();
+
+const child = cp.spawn(command, { env });
+
+child.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ assert.strictEqual(err.syscall, `spawn ${command}`);
+}));
+
+// Also test sync
+try {
+ cp.spawnSync(command, { env });
+} catch (err) {
+ assert.strictEqual(err.code, 'ENOENT');
+}
+
+// Case: File exists but is not executable. Should NOT be normalized to ENOENT.
+if (!common.isWindows) {
+ const nonExecFile = path.join(tmpdir.path, 'non-executable');
+ fs.writeFileSync(nonExecFile, 'echo "should not run"');
+ fs.chmodSync(nonExecFile, '644');
+
+ const env2 = { ...process.env, PATH: tmpdir.path };
+ const child2 = cp.spawn('non-executable', { env: env2 });
+ child2.on('error', common.mustCall((err) => {
+ // It should stay EACCES because the file actually exists
+ assert.strictEqual(err.code, 'EACCES');
+ }));
+
+ // Also test empty PATH entry
+ const env3 = { ...process.env, PATH: `${path.delimiter}${env.PATH}` };
+ const child3 = cp.spawn(command, { env: env3 });
+ child3.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+}
+
+// Case: No PATH in envPairs
+const env4 = { ...process.env };
+delete env4.PATH;
+const child4 = cp.spawn(command, { env: env4 });
+child4.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+}));
+
+// Case: envPath ||= process.env.PATH (no env passed)
+if (!common.isWindows) {
+ const oldPath = process.env.PATH;
+ process.env.PATH = `${noPermDir}${path.delimiter}${oldPath}`;
+ try {
+ const child5 = cp.spawn(command);
+ child5.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ENOENT');
+ }));
+ } finally {
+ process.env.PATH = oldPath;
+ }
+}