process: add process.entrypoint

doc/api/process.md

@@ -1513,6 +1513,18 @@ emitMyWarning();
 // Emits nothing
 ```
 
+## `process.entrypoint`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {string | undefined}
+
+The URL of the entry point that Node.js was started with, such as
+`'file:///path/to/app.js'`. Worker threads inherit this value. If Node.js was
+started without an entry point, such as in the REPL, the value is {undefined}.
+
 ## `process.env`
 
 <!-- YAML

lib/internal/main/worker_thread.js

@@ -14,6 +14,7 @@ const {
 } = primordials;
 
 const {
+  defineEntrypoint,
   prepareWorkerThreadExecution,
   initializeModuleLoaders,
   markBootstrapComplete,
@@ -95,6 +96,7 @@ port.on('message', (message) => {
       argv,
       cwdCounter,
       doEval,
+      entrypoint,
       environmentData,
       filename,
       hasStdin,
@@ -103,6 +105,8 @@ port.on('message', (message) => {
       mainThreadPort,
     } = message;
 
+    defineEntrypoint(() => entrypoint);
+
     if (doEval !== 'internal') {
       if (argv !== undefined) {
         ArrayPrototypePushApply(process.argv, argv);

lib/internal/process/pre_execution.js

@@ -27,6 +27,7 @@ const {
   setupCoverageHooks,
   emitExperimentalWarning,
   deprecate,
+  getCWDURL,
 } = require('internal/util');
 
 const {
@@ -254,6 +255,25 @@ function refreshRuntimeOptions() {
   refreshOptions();
 }
 
+function defineEntrypoint(computeEntrypoint) {
+  let entrypoint;
+  let computed = false;
+
+  ObjectDefineProperty(process, 'entrypoint', {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      if (!computed) {
+        entrypoint = computeEntrypoint();
+        computed = true;
+      }
+      return entrypoint;
+    },
+    set: undefined,
+  });
+}
+
 /**
  * Patch the process object with legacy properties and normalizations.
  * Replace `process.argv[0]` with `process.execPath`, preserving the original `argv[0]` value as `process.argv0`.
@@ -294,6 +314,19 @@ function patchProcessObject(expandArgv1) {
     }
   }
 
+  const entryArg = process.argv[1];
+  defineEntrypoint(() => {
+    if (mainEntry !== undefined) {
+      const { pathToFileURL } = require('internal/url');
+      return pathToFileURL(mainEntry).href;
+    }
+    if (entryArg && getOptionValue('--entry-url')) {
+      const { URL } = require('internal/url');
+      return new URL(entryArg, getCWDURL()).href;
+    }
+    return undefined;
+  });
+
   // We need to initialize the global console here again with process.stdout
   // and friends for snapshot deserialization.
   const globalConsole = require('internal/console/global');
@@ -824,6 +857,7 @@ function getHeapSnapshotFilename(diagnosticDir) {
 }
 
 module.exports = {
+  defineEntrypoint,
   initializeModuleLoaders,
   prepareMainThreadExecution,
   prepareWorkerThreadExecution,

lib/internal/worker.js

@@ -362,6 +362,7 @@ class Worker extends EventEmitter {
 
     this[kPort].postMessage({
       argv,
+      entrypoint: process.entrypoint,
       type: messageTypes.LOAD_SCRIPT,
       filename,
       doEval,

test/fixtures/entrypoint/check-commonjs.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+const assert = require('node:assert');
+
+assert.strictEqual(process.entrypoint, process.env.NODE_TEST_ENTRYPOINT);

test/fixtures/entrypoint/check-module.mjs

@@ -0,0 +1,4 @@
+import assert from 'node:assert';
+import { entrypoint } from 'node:process';
+
+assert.strictEqual(entrypoint, process.env.NODE_TEST_ENTRYPOINT);

test/fixtures/entrypoint/commonjs.cjs

@@ -0,0 +1 @@
+console.log(process.entrypoint);

test/fixtures/entrypoint/loader.mjs

@@ -0,0 +1,4 @@
+import assert from 'node:assert';
+import { entrypoint } from 'node:process';
+
+assert.strictEqual(entrypoint, process.env.NODE_TEST_ENTRYPOINT);

test/fixtures/entrypoint/module.mjs

@@ -0,0 +1 @@
+console.log(process.entrypoint);

test/fixtures/entrypoint/worker.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+const { isMainThread, workerData, Worker } = require('node:worker_threads');
+
+if (isMainThread || workerData === 'nested') {
+  new Worker(__filename, { workerData: isMainThread ? 'nested' : 'leaf' });
+} else {
+  console.log(process.entrypoint);
+}

test/parallel/test-process-entrypoint.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const { spawnPromisified } = require('../common');
+const fixtures = require('../common/fixtures');
+
+const assert = require('node:assert');
+const { execPath } = require('node:process');
+const { describe, it } = require('node:test');
+
+const cjsFixture = fixtures.path('entrypoint', 'commonjs.cjs');
+const cjsFixtureURL = fixtures.fileURL('entrypoint', 'commonjs.cjs').href;
+
+const mjsFixture = fixtures.path('entrypoint', 'module.mjs');
+const mjsFixtureURL = fixtures.fileURL('entrypoint', 'module.mjs').href;
+
+const workerFixture = fixtures.path('entrypoint', 'worker.cjs');
+const workerFixtureURL = fixtures.fileURL('entrypoint', 'worker.cjs').href;
+
+const cjsPreload = fixtures.path('entrypoint', 'check-commonjs.cjs');
+const esmPreload = fixtures.fileURL('entrypoint', 'check-module.mjs').href;
+const loader = fixtures.fileURL('entrypoint', 'loader.mjs').href;
+
+const printEntrypoint = 'console.log(process.entrypoint)';
+
+async function getEntrypoint(args, options, expected) {
+  const { code, signal, stderr, stdout } = await spawnPromisified(
+    execPath,
+    args,
+    {
+      ...options,
+      env: {
+        ...process.env,
+        NODE_TEST_ENTRYPOINT: expected,
+      },
+    },
+  );
+  assert.strictEqual(code, 0, stderr);
+  assert.strictEqual(signal, null);
+
+  return stdout.trim();
+}
+
+const testCases = [
+  {
+    name: 'is the file URL of a CommonJS entry point',
+    args: [cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'is the file URL of an ES module entry point',
+    args: [mjsFixture],
+    expected: mjsFixtureURL,
+  },
+  {
+    name: 'is absolute when passed a relative path',
+    args: ['./commonjs.cjs'],
+    options: { cwd: fixtures.path('entrypoint') },
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when using --require',
+    args: ['--require', cjsPreload, cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when using --import',
+    args: ['--import', esmPreload, cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when using --loader',
+    args: ['--loader', loader, cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when combining preloads and loaders',
+    args: [
+      '--require', cjsPreload,
+      '--import', esmPreload,
+      '--loader', loader,
+      mjsFixture,
+    ],
+    expected: mjsFixtureURL,
+  },
+  {
+    name: 'is inherited by worker threads and their preloads and loaders',
+    args: [
+      '--require', cjsPreload,
+      '--import', esmPreload,
+      '--loader', loader,
+      workerFixture,
+    ],
+    expected: workerFixtureURL,
+  },
+  {
+    name: 'supports non-file --entry-url entry points',
+    args: ['--entry-url', `data:text/javascript,${printEntrypoint}`],
+    expected: `data:text/javascript,${printEntrypoint}`,
+  },
+  {
+    name: 'is undefined when evaluating CommonJS without an entry point',
+    args: ['--eval', printEntrypoint],
+    expected: 'undefined',
+  },
+  {
+    name: 'is undefined when evaluating an ES module without an entry point',
+    args: ['--input-type=module', '--eval', printEntrypoint],
+    expected: 'undefined',
+  },
+];
+
+describe('process.entrypoint', { concurrency: true }, () => {
+  for (const { name, args, options, expected } of testCases) {
+    it(name, async () => {
+      assert.strictEqual(await getEntrypoint(args, options, expected), expected);
+    });
+  }
+});