From 5afffb4415b6c63525076202fb9490b40af64dcd Mon Sep 17 00:00:00 2001
From: Carlos Espa <43477095+Ceres6@users.noreply.github.com>
Date: Tue, 14 Jan 2025 19:24:30 +0100
Subject: [PATCH] src,worker: add isInternalWorker

PR-URL: https://github.com/nodejs/node/pull/56469
Reviewed-By: Jacob Smith <jacob@frende.me>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Bryan English <bryan@bryanenglish.com>
---
 doc/api/worker_threads.md                  | 38 ++++++++++++++++++++++
 lib/internal/worker.js                     |  2 ++
 lib/worker_threads.js                      |  2 ++
 src/node_worker.cc                         | 19 +++++++++--
 src/node_worker.h                          |  5 ++-
 test/fixtures/loader-is-internal-thread.js |  3 ++
 test/fixtures/worker-is-internal-thread.js |  3 ++
 test/parallel/test-is-internal-thread.mjs  | 36 ++++++++++++++++++++
 8 files changed, 104 insertions(+), 4 deletions(-)
 create mode 100644 test/fixtures/loader-is-internal-thread.js
 create mode 100644 test/fixtures/worker-is-internal-thread.js
 create mode 100644 test/parallel/test-is-internal-thread.mjs

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 36a088027edc5f..d9f6e356fd7519 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -100,6 +100,44 @@ if (isMainThread) {
 }
 ```
 
+## `worker.isInternalThread`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+Is `true` if this code is running inside of an internal [`Worker`][] thread (e.g the loader thread).
+
+```bash
+node --experimental-loader ./loader.js main.js
+```
+
+```cjs
+// loader.js
+const { isInternalThread } = require('node:worker_threads');
+console.log(isInternalThread);  // true
+```
+
+```mjs
+// loader.js
+import { isInternalThread } from 'node:worker_threads';
+console.log(isInternalThread);  // true
+```
+
+```cjs
+// main.js
+const { isInternalThread } = require('node:worker_threads');
+console.log(isInternalThread);  // false
+```
+
+```mjs
+// main.js
+import { isInternalThread } from 'node:worker_threads';
+console.log(isInternalThread);  // false
+```
+
 ## `worker.isMainThread`
 
 <!-- YAML
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 84ae104d4b9588..dcc9651802c4e4 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -67,6 +67,7 @@ const {
 const {
   ownsProcessState,
   isMainThread,
+  isInternalThread,
   resourceLimits: resourceLimitsRaw,
   threadId,
   Worker: WorkerImpl,
@@ -538,6 +539,7 @@ module.exports = {
   ownsProcessState,
   kIsOnline,
   isMainThread,
+  isInternalThread,
   SHARE_ENV,
   resourceLimits:
     !isMainThread ? makeResourceLimits(resourceLimitsRaw) : {},
diff --git a/lib/worker_threads.js b/lib/worker_threads.js
index e874671ea12221..1e7a175fc8638e 100644
--- a/lib/worker_threads.js
+++ b/lib/worker_threads.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  isInternalThread,
   isMainThread,
   SHARE_ENV,
   resourceLimits,
@@ -29,6 +30,7 @@ const {
 } = require('internal/buffer');
 
 module.exports = {
+  isInternalThread,
   isMainThread,
   MessagePort,
   MessageChannel,
diff --git a/src/node_worker.cc b/src/node_worker.cc
index bae606861eb1c6..1fc3774948dae3 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -54,7 +54,8 @@ Worker::Worker(Environment* env,
                std::shared_ptr<PerIsolateOptions> per_isolate_opts,
                std::vector<std::string>&& exec_argv,
                std::shared_ptr<KVStore> env_vars,
-               const SnapshotData* snapshot_data)
+               const SnapshotData* snapshot_data,
+               const bool is_internal)
     : AsyncWrap(env, wrap, AsyncWrap::PROVIDER_WORKER),
       per_isolate_opts_(per_isolate_opts),
       exec_argv_(exec_argv),
@@ -63,7 +64,8 @@ Worker::Worker(Environment* env,
       name_(name),
       env_vars_(env_vars),
       embedder_preload_(env->embedder_preload()),
-      snapshot_data_(snapshot_data) {
+      snapshot_data_(snapshot_data),
+      is_internal_(is_internal) {
   Debug(this, "Creating new worker instance with thread id %llu",
         thread_id_.id);
 
@@ -685,7 +687,8 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
                               per_isolate_opts,
                               std::move(exec_argv_out),
                               env_vars,
-                              snapshot_data);
+                              snapshot_data,
+                              is_internal);
 
   CHECK(args[3]->IsFloat64Array());
   Local<Float64Array> limit_info = args[3].As<Float64Array>();
@@ -1028,6 +1031,16 @@ void CreateWorkerPerContextProperties(Local<Object> target,
             Boolean::New(isolate, env->is_main_thread()))
       .Check();
 
+  Worker* worker = env->isolate_data()->worker_context();
+  bool is_internal = worker != nullptr && worker->is_internal();
+
+  // Set the is_internal property
+  target
+      ->Set(env->context(),
+            FIXED_ONE_BYTE_STRING(isolate, "isInternalThread"),
+            Boolean::New(isolate, is_internal))
+      .Check();
+
   target
       ->Set(env->context(),
             FIXED_ONE_BYTE_STRING(isolate, "ownsProcessState"),
diff --git a/src/node_worker.h b/src/node_worker.h
index 07fd7b460654e1..c1d8619d28a908 100644
--- a/src/node_worker.h
+++ b/src/node_worker.h
@@ -34,7 +34,8 @@ class Worker : public AsyncWrap {
          std::shared_ptr<PerIsolateOptions> per_isolate_opts,
          std::vector<std::string>&& exec_argv,
          std::shared_ptr<KVStore> env_vars,
-         const SnapshotData* snapshot_data);
+         const SnapshotData* snapshot_data,
+         const bool is_internal);
   ~Worker() override;
 
   // Run the worker. This is only called from the worker thread.
@@ -60,6 +61,7 @@ class Worker : public AsyncWrap {
 
   bool is_stopped() const;
   const SnapshotData* snapshot_data() const { return snapshot_data_; }
+  bool is_internal() const { return is_internal_; }
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void CloneParentEnvVars(
@@ -132,6 +134,7 @@ class Worker : public AsyncWrap {
   Environment* env_ = nullptr;
 
   const SnapshotData* snapshot_data_ = nullptr;
+  const bool is_internal_;
   friend class WorkerThreadData;
 };
 
diff --git a/test/fixtures/loader-is-internal-thread.js b/test/fixtures/loader-is-internal-thread.js
new file mode 100644
index 00000000000000..d97328bc2075ac
--- /dev/null
+++ b/test/fixtures/loader-is-internal-thread.js
@@ -0,0 +1,3 @@
+const { isInternalThread } = require('node:worker_threads');
+
+console.log(`isInternalThread: ${isInternalThread}`);
\ No newline at end of file
diff --git a/test/fixtures/worker-is-internal-thread.js b/test/fixtures/worker-is-internal-thread.js
new file mode 100644
index 00000000000000..7e3f1f413830ca
--- /dev/null
+++ b/test/fixtures/worker-is-internal-thread.js
@@ -0,0 +1,3 @@
+const { isInternalThread, parentPort } = require('node:worker_threads');
+
+parentPort.postMessage(`isInternalThread: ${isInternalThread}`);
\ No newline at end of file
diff --git a/test/parallel/test-is-internal-thread.mjs b/test/parallel/test-is-internal-thread.mjs
new file mode 100644
index 00000000000000..dd8af897c219ba
--- /dev/null
+++ b/test/parallel/test-is-internal-thread.mjs
@@ -0,0 +1,36 @@
+import { spawnPromisified } from '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import assert from 'node:assert';
+import { execPath } from 'node:process';
+import { describe, it } from 'node:test';
+import { isInternalThread, Worker } from 'node:worker_threads';
+import * as common from '../common/index.mjs';
+
+describe('worker_threads.isInternalThread', { concurrency: !process.env.TEST_PARALLEL }, () => {
+  it('should be true inside the loader thread', async () => {
+    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+      '--no-warnings',
+      '--experimental-loader',
+      fixtures.fileURL('loader-is-internal-thread.js'),
+      '--eval',
+      'setTimeout(() => {},99)',
+    ]);
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /isInternalThread: true/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should be false inside the main thread', async () => {
+    assert.strictEqual(isInternalThread, false);
+  });
+
+  it('should be false inside a regular worker thread', async () => {
+    const worker = new Worker(fixtures.path('worker-is-internal-thread.js'));
+
+    worker.on('message', common.mustCall((message) => {
+      assert.strictEqual(message, 'isInternalThread: false');
+    }));
+  });
+});