cli: implement node run <script-in-package-json>

Author: anonrig

doc/api/cli.md

@@ -51,6 +51,28 @@ entry point, the `node` command will accept as input only files with `.js`,
 [`--experimental-wasm-modules`][] is enabled; and with no extension when
 [`--experimental-default-type=module`][] is passed.
 
+## Sub-commands
+
+### `node run [command]`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+This runs an arbitrary command from a package.json's `"scripts"` object.
+If no `"command"` is provided, it will list the available scripts.
+
+By default, this command adds the current path appended by
+`node_modules/.bin` directory to the PATH in order to execute the binaries
+from dependencies.
+
+For example, the following command will run the `test` script of
+the current project's `package.json`:
+
+```console
+$ node run test
+```
+
 ## Options
 
 <!-- YAML

lib/internal/main/run.js

@@ -0,0 +1,62 @@
+'use strict';
+/* eslint-disable node-core/prefer-primordials */
+
+// There is no need to add primordials to this file.
+// `run.js` is a script only executed when `node run <script>` is called.
+const {
+  prepareMainThreadExecution,
+  markBootstrapComplete,
+} = require('internal/process/pre_execution');
+const { getPackageJSONScripts } = internalBinding('modules');
+const { execSync } = require('child_process');
+const { resolve, delimiter } = require('path');
+
+prepareMainThreadExecution(false, false);
+
+markBootstrapComplete();
+
+// TODO(@anonrig): Search for all package.json's until root folder.
+const json_string = getPackageJSONScripts();
+
+// Check if package.json exists and is parseable
+if (json_string === undefined) {
+  process.exit(1);
+  return;
+}
+const scripts = JSON.parse(json_string);
+const id = process.argv.at(2);
+const command = scripts[id];
+
+if (!command) {
+  const { error } = require('internal/console/global');
+
+  error(`Missing script: "${id}"`);
+
+  const keys = Object.keys(scripts);
+  if (keys.length === 0) {
+    error('There are no scripts available in package.json');
+  } else {
+    error('Available scripts are:\n');
+    for (const script of keys) {
+      error(`  ${script}: ${scripts[script]}`);
+    }
+  }
+  process.exit(1);
+  return;
+}
+
+const env = process.env;
+const cwd = process.cwd();
+const binPath = resolve(cwd, 'node_modules/.bin');
+
+// Filter all environment variables that contain the word "path"
+const keys = Object.keys(env).filter((key) => /^path$/i.test(key));
+const PATH = keys.map((key) => env[key]);
+
+// Append only the current folder bin path to the PATH variable.
+// TODO(@anonrig): Add support for appending the bin path of all parent folders.
+const paths = [binPath, PATH].join(delimiter);
+for (const key of keys) {
+  env[key] = paths;
+}
+execSync(command, { stdio: 'inherit', env });

src/node.cc

@@ -409,6 +409,10 @@ MaybeLocal<Value> StartExecution(Environment* env, StartExecutionCallback cb) {
     return StartExecution(env, "internal/main/watch_mode");
   }
 
+  if (!first_argv.empty() && first_argv == "run") {
+    return StartExecution(env, "internal/main/run");
+  }
+
   if (!first_argv.empty() && first_argv != "-") {
     return StartExecution(env, "internal/main/run_main_module");
   }

src/node_modules.cc

@@ -219,6 +219,21 @@ const BindingData::PackageConfig* BindingData::GetPackageJSON(
       if (field_value == "commonjs" || field_value == "module") {
         package_config.type = field_value;
       }
+    } else if (key == "scripts") {
+      if (value.type().get(field_type)) {
+        return throw_invalid_package_config();
+      }
+      switch (field_type) {
+        case simdjson::ondemand::json_type::object: {
+          if (value.raw_json().get(field_value)) {
+            return throw_invalid_package_config();
+          }
+          package_config.scripts = field_value;
+          break;
+        }
+        default:
+          break;
+      }
     }
   }
   // package_config could be quite large, so we should move it instead of
@@ -344,6 +359,28 @@ void BindingData::GetNearestParentPackageJSONType(
   args.GetReturnValue().Set(Array::New(realm->isolate(), values, 3));
 }
 
+void BindingData::GetPackageJSONScripts(
+    const FunctionCallbackInfo<Value>& args) {
+  Realm* realm = Realm::GetCurrent(args);
+  std::string path = "package.json";
+
+  THROW_IF_INSUFFICIENT_PERMISSIONS(
+      realm->env(), permission::PermissionScope::kFileSystemRead, path);
+
+  auto package_json = GetPackageJSON(realm, path);
+  if (package_json == nullptr) {
+    printf("Can't read package.json\n");
+    return;
+  } else if (!package_json->scripts.has_value()) {
+    printf("Package.json scripts doesn't exist or parseable\n");
+    return;
+  }
+
+  args.GetReturnValue().Set(
+      ToV8Value(realm->context(), package_json->scripts.value())
+          .ToLocalChecked());
+}
+
 void BindingData::GetPackageScopeConfig(
     const FunctionCallbackInfo<Value>& args) {
   CHECK_GE(args.Length(), 1);
@@ -424,6 +461,7 @@ void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
             "getNearestParentPackageJSON",
             GetNearestParentPackageJSON);
   SetMethod(isolate, target, "getPackageScopeConfig", GetPackageScopeConfig);
+  SetMethod(isolate, target, "getPackageJSONScripts", GetPackageJSONScripts);
 }
 
 void BindingData::CreatePerContextProperties(Local<Object> target,
@@ -440,6 +478,7 @@ void BindingData::RegisterExternalReferences(
   registry->Register(GetNearestParentPackageJSONType);
   registry->Register(GetNearestParentPackageJSON);
   registry->Register(GetPackageScopeConfig);
+  registry->Register(GetPackageJSONScripts);
 }
 
 }  // namespace modules

src/node_modules.h

@@ -32,6 +32,7 @@ class BindingData : public SnapshotableObject {
     std::string type = "none";
     std::optional<std::string> exports;
     std::optional<std::string> imports;
+    std::optional<std::string> scripts;
     std::string raw_json;
 
     v8::Local<v8::Array> Serialize(Realm* realm) const;
@@ -60,6 +61,8 @@ class BindingData : public SnapshotableObject {
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetPackageScopeConfig(
       const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPackageJSONScripts(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void CreatePerIsolateProperties(IsolateData* isolate_data,
                                          v8::Local<v8::ObjectTemplate> ctor);

test/fixtures/run-script/node_modules/.bin/fastify

@@ -0,0 +1,6 @@
+{
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "fastify": "fastify"
+  }
+}

test/fixtures/run-script/package.json

@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+const { it, describe } = require('node:test');
+const assert = require('node:assert');
+
+const fixtures = require('../common/fixtures');
+const isLinuxOrOSX = common.isLinux || common.isOSX;
+
+describe('node run [command]', () => {
+  it('returns error on non-existent command', async () => {
+    const child = await common.spawnPromisified(
+      process.execPath,
+      [ 'run', 'test'],
+      { cwd: __dirname },
+    );
+    assert.strictEqual(child.stdout, 'Can\'t read package.json\n');
+    assert.strictEqual(child.stderr, '');
+    assert.strictEqual(child.code, 1);
+  });
+
+  it('runs a valid command', { skip: !isLinuxOrOSX }, async () => {
+    // Run a script that just log `no test specified`
+    const child = await common.spawnPromisified(
+      process.execPath,
+      [ 'run', 'test'],
+      { cwd: fixtures.path('run-script') },
+    );
+    assert.strictEqual(child.stdout, 'Error: no test specified\n');
+    assert.strictEqual(child.code, 1);
+  });
+
+  it('adds node_modules/.bin to path', { skip: !isLinuxOrOSX }, async () => {
+    const child = await common.spawnPromisified(
+      process.execPath,
+      [ 'run', 'fastify'],
+      { cwd: fixtures.path('run-script') },
+    );
+    assert.strictEqual(child.stdout, 'this is fastify\n');
+    assert.strictEqual(child.stderr, '');
+    assert.strictEqual(child.code, 0);
+  });
+});

test/parallel/test-node-run.js

@@ -26,4 +26,5 @@ export interface ModulesBinding {
     string, // raw content
   ]
   getPackageScopeConfig(path: string): SerializedPackageConfig | undefined
+  getPackageJSONScripts(): string | undefined
 }