process.cwd() gives different results when called with different package managers.

[btea]

I started a terminal locally, as shown below. (Note that the path starts with lowercase.)

I wrote a simple code test as shown below.

When I start the script using pnpm and npm, I get two different results. I noticed that when I started it with pnpm, the first line of information printed had an additional capitalized path compared to when I started it with npm.

I tried debugging the code, but I couldn't see the implementation inside rawMethods.cwd().

const rawMethods = internalBinding('process_methods');

function wrappedCwd() {
  if (cachedCwd === '')
    cachedCwd = rawMethods.cwd();
  return cachedCwd;
}

If you have time, please take a look, thank you. @redyetidev

[avivkeller]

What happens when you just run the file? With no package managers?

[btea]

As shown in the figure below, the path starting with lowercase is printed directly.

[avivkeller]

So this may be a PNPM issue?

[btea]

I'm not sure, I'll try to check out pnpm, thanks for your reply.

[btea]

I encountered another problem about process.argv. I wrote a test file test.mjs with the following content:

console.log(process.argv.slice(2));

When I execute node test.mjs config set save-prefix '' --location=project in different terminals, I get different results.

cmd	powershell
[ 'config', 'set', 'save-prefix', "''", '--location=project' ]	[ 'config', 'set', 'save-prefix', '--location=project' ]

Could you please help me take a look? Thanks. @avivkeller

[Felipeness]

Windows being Windows. NTFS is case-insensitive but case-preserving, so the actual stored path might be C:/Users/... but if a process does chdir("c:/users/..."), then GetCurrentDirectoryW returns the lowercase version — whatever casing was used when the directory was last set.

The difference you're seeing comes from how npm and pnpm spawn child processes:

• npm inherits the shell's current directory as-is (lowercase in your case)
• pnpm resolves or normalizes the path before spawning, which changes the casing to match the actual filesystem casing (C:/Users/...)

Neither is wrong. Both paths point to the same directory.

If you need consistent casing, realpathSync.native gives you the actual filesystem casing:

import { realpathSync } from "node:fs";

const canonicalCwd = realpathSync.native(process.cwd());

Or for path comparison, just go case-insensitive on Windows:

import path from "node:path";

function samePath(a, b) {
  return path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
}

Regarding your follow-up about process.argv differences between CMD and PowerShell — also not a Node issue. CMD passes '' as a literal two-character string, while PowerShell interprets '' as an empty string and removes it from the argument list. Use double quotes in PowerShell to pass an empty string argument. Standard shell quoting behavior on Windows, ran into this before myself.

[Errr0rr404]

process.cwd() is the process current working directory, not “where the entry file lives”. Different package managers / how you launch the script can start Node with different CWDs.

Typical causes:

• Running via npm test / pnpm / yarn from repo root vs node path/to/file.js from another folder
• IDE run configs with a custom working directory
• Case-insensitive macOS paths displaying differently (/Users/... vs shell cwd)

What to use instead when you mean “directory of this package/file”:

import path from "node:path";
import { fileURLToPath } from "node:url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
// stable regardless of cwd

Or for the package root, walk up to the nearest package.json from __dirname.

So: normalize on __dirname / import.meta.url for path resolution; use process.cwd() only when you truly want the user’s launch directory.

[k4hvecii]

The output from process.cwd() actually seems to be the same in both cases: c:\a.

The extra C:\a shown when running pnpm test is not produced by process.cwd(). It is part of pnpm's lifecycle script output.

With npm you get something like:

npm:
a@1.0.0 test
node z.mjs
c:\a

While pnpm prints the package directory in its script header:

pnpm:
a@1.0.0 test C:\a
node z.mjs
c:\a

So the Node.js process itself is still reporting c:\a in both cases.

The difference between C:\a and c:\a is also not significant on Windows because Windows paths are normally case-insensitive.

Therefore I don't think this is caused by the implementation of process.cwd() or rawMethods.cwd(). It looks like a formatting difference between npm and pnpm's lifecycle output.

If you want to verify it independently of the package manager output, you can run:

node -e "console.log(process.cwd())"

from the same directory and compare that result.