@reboot-dev/reboot 0.19.0 → 0.19.2

package/package.json

@@ -1,30 +1,35 @@
 {
   "dependencies": {
-    "@types/node": "20.11.5",
-    "@types/uuid": "^9.0.4",
-    "uuid": "^9.0.1",
-    "node-addon-api": "^7.0.0",
-    "protobufjs": "^7.2.5",
-    "chalk": "^4.1.2"
-  },
-  "peerDependencies": {
     "@bufbuild/protobuf": "1.3.2",
     "@bufbuild/protoplugin": "1.3.2",
     "@bufbuild/protoc-gen-es": "1.3.2",
-    "@reboot-dev/reboot-api": "0.19.0",
-    "typescript": ">=4.9.5"
+    "@reboot-dev/reboot-api": "0.19.2",
+    "chalk": "^4.1.2",
+    "node-addon-api": "^7.0.0",
+    "node-gyp": ">=10.2.0",
+    "uuid": "^9.0.1",
+    "which-pm-runs": "^1.1.0",
+    "extensionless": "^1.9.9",
+    "esbuild": "^0.24.0"
   },
   "type": "module",
   "name": "@reboot-dev/reboot",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "description": "npm package for Reboot",
   "scripts": {
     "postinstall": "rbt || exit 0",
     "test": "echo \"Error: no test specified\" && exit 1",
-    "prepare": "tsc"
+    "prepack": "tsc"
+  },
+  "devDependencies": {
+    "typescript": ">=4.9.5",
+    "@types/node": "20.11.5",
+    "@types/uuid": "^9.0.4"
   },
   "bin": {
-    "rbt": "./rbt.js"
+    "rbt": "./rbt.js",
+    "rbt-esbuild": "./rbt-esbuild.js",
+    "protoc-gen-es": "./protoc-gen-es.js"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -34,22 +39,27 @@
   "author": "reboot-dev",
   "license": "Apache-2.0",
   "files": [
+    "binding.gyp",
     "include",
     "internal",
-    "utils",
-    "binding.gyp",
     "package.json",
+    "protoc-gen-es.d.ts",
+    "protoc-gen-es.js",
+    "rbt.d.ts",
+    "rbt-esbuild.d.ts",
+    "rbt-esbuild.js",
+    "rbt.js",
+    "reboot.d.ts",
+    "reboot.js",
     "reboot_native.cc",
     "reboot_native.cjs",
     "reboot_native.d.ts",
-    "reboot.js",
-    "reboot.d.ts",
-    "rbt.js",
-    "rbt.d.ts",
-    "venv.js",
+    "utils",
     "venv.d.ts",
+    "venv.js",
+    "version.d.ts",
     "version.js",
-    "version.d.ts"
+    "workspaces.js"
   ],
   "exports": {
     "./package.json": "./package.json",

package/protoc-gen-es.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "@bufbuild/protoc-gen-es/bin/protoc-gen-es";

package/protoc-gen-es.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// NOTE: Yarn doesn't add transitive binary dependencies to PATH!!!
+// Thus this script which "proxies" to `protoc-gen-es`.
+import "@bufbuild/protoc-gen-es/bin/protoc-gen-es";

package/rbt-esbuild.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare const BUNDLE_PATH: string;

package/rbt-esbuild.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import esbuild from "esbuild";
+import { writeFileSync } from "node:fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { locateWorkspaces } from "./workspaces.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Expected usage: rbt-esbuild path/to/application.ts name
+const args = process.argv.slice(2);
+const application = args[0];
+const name = args[1];
+export const BUNDLE_PATH = path.join(__dirname, ".bundles", name);
+let workspaces = [];
+try {
+    workspaces = (await locateWorkspaces()).map(({ name }) => name);
+}
+catch (e) {
+    console.error(chalk.stderr.bold.red(`Failed to use your package manager to determine your workspaces (if any): ${e}`));
+    process.exit(-1);
+}
+const plugin = {
+    name: "rbt-esbuild",
+    setup(build) {
+        build.onResolve({ namespace: "file", filter: /.*/ }, (args) => {
+            // Do not mark as 'external' files starting with '.' or '/' because those
+            // are assumed to be local.
+            if (args.path.startsWith(".") || args.path.startsWith("/")) {
+                return null;
+            }
+            // Workspace modules are also local, not external.
+            for (const workspace of workspaces) {
+                if (args.path === workspace || args.path.startsWith(workspace + "/")) {
+                    return null;
+                }
+            }
+            // Mark everything else external.
+            return { path: args.path, external: true };
+        });
+    },
+};
+esbuild
+    .build({
+    entryPoints: [application],
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    metafile: true,
+    sourcemap: "inline",
+    banner: {
+        js: "/* eslint-disable */",
+    },
+    outfile: path.join(BUNDLE_PATH, "bundle.js"),
+    plugins: [plugin],
+    // This is only called by `rbt dev` and thus should only do module
+    // resolution for "development".
+    conditions: ["development"],
+    // TODO: support taking either `esbuild.config.js` or a more
+    // general `rbt.config.js` which would export a default object
+    // with options to pass on for specific esbuild, for example:
+    //
+    // export default {
+    //   esbuild: {
+    //     conditions: ["something"]
+    //   }
+    // };
+    //
+    // We'll likely need to have users pass us the path to this file
+    // via some flag like
+    // `--esbuild-config=path/to/esbuild.config.js` or
+    // `--nodejs-config=path/to/rbt.config.js`.
+    //
+    // We could try to find the file but it's not obvious where to
+    // look. We could look for it based on `.rbtrc` or
+    // `--state-directory` (which ever was specified) but it's not
+    // obvious it should always be there, e.g., in the case of a
+    // monorepo with a `.rbtrc` that has "config" based flags.
+    //
+    // Once we have the file we can support overriding, for example:
+    //
+    // ...("conditions" in config.esbuild && { conditions: config.esbuild.conditions } ||  {}),
+})
+    .then(async (result) => {
+    writeFileSync(path.join(BUNDLE_PATH, "meta.json"), JSON.stringify(result.metafile));
+    // Output the path where we bundled for `rbt dev` to consume.
+    console.log(BUNDLE_PATH);
+    process.exit(0);
+})
+    .catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(-1);
+});

package/rbt.js

@@ -1,11 +1,48 @@
 #!/usr/bin/env node
 import { spawnSync } from "child_process";
 import * as path from "path";
+import whichPMRuns from "which-pm-runs";
+import { ensureYarnNodeLinker } from "./utils/index.js";
 import { ensurePythonVenv, VENV_EXEC_PATH } from "./venv.js";
+async function ensureSupportedYarn() {
+    const packageManager = await whichPMRuns();
+    if (!packageManager) {
+        return;
+    }
+    if (packageManager.name === "yarn") {
+        ensureYarnNodeLinker();
+    }
+}
+function addExtensionlessToNodeOptions() {
+    // Add the `extensionless` loader to the `NODE_OPTIONS` env var so
+    // subsequent invocations of Node.js will use it. Depending on which
+    // version of Node.js we're using we have to add it differently.
+    const [major, minor] = process.versions.node.split(".").map(Number);
+    // Make sure that we can append to the `NODE_OPTIONS` env var.
+    process.env.NODE_OPTIONS =
+        (process.env.NODE_OPTIONS && process.env.NODE_OPTIONS + " ") || "";
+    // The `module.register()` function was added to Node.js in 20.6.0
+    // for the main release line and 18.19.0 for the LTS release line.
+    //
+    // If we have one of those two versions then we can pre import
+    // `extensionless/register` to use the `module.register()` function,
+    // otherwise we need to fall back to `--experimental-loader`.
+    if (major > 20 ||
+        (major == 20 && minor >= 6) ||
+        (major == 18 && minor >= 19)) {
+        process.env.NODE_OPTIONS += "--import=extensionless/register";
+    }
+    else {
+        process.env.NODE_OPTIONS += "--experimental-loader=extensionless";
+    }
+}
 async function main() {
     ensurePythonVenv();
+    await ensureSupportedYarn();
     // Set env var to indicate that `rbt` is being invoked from Node.js.
     process.env.RBT_FROM_NODEJS = "true";
+    // Add extensionless loader.
+    addExtensionlessToNodeOptions();
     const rbt = spawnSync(`${path.join(VENV_EXEC_PATH, "rbt")} ${process.argv.slice(2).join(" ")}`, {
         stdio: [process.stdin, process.stdout, process.stderr],
         shell: true,

package/reboot.d.ts

@@ -150,9 +150,10 @@ export declare class AllowAllIfAuthenticated extends Authorizer<protobuf_es.Mess
 }
 export declare class Application {
     #private;
-    constructor({ servicers, initialize, tokenVerifier, }: {
+    constructor({ servicers, initialize, initializeBearerToken, tokenVerifier, }: {
         servicers: ServicerFactory[];
         initialize?: (context: ExternalContext) => Promise<void>;
+        initializeBearerToken?: string;
         tokenVerifier?: TokenVerifier;
     });
     run(): Promise<any>;

package/reboot.js

@@ -21,15 +21,34 @@ export { reboot_native };
 export * from "./utils/index.js";
 const startedInstances = [];
 if (process != null) {
-    const processExitHandler = () => {
-        if (startedInstances.length) {
-            console.warn(`${startedInstances.length} Reboot instance(s) still running on exit. Did you forget to run \`rbt.stop()\`?`);
+    const checkForStartedInstances = () => {
+        if (startedInstances.length > 0) {
+            console.warn(`${startedInstances.length} Reboot instance(s) still running on exit which may keep your process from exiting. Did you forget to run \`rbt.stop()\`?`);
         }
-        process.exit(0);
     };
-    process.on("exit", processExitHandler);
-    process.on("SIGTERM", processExitHandler);
-    process.on("SIGINT", processExitHandler);
+    process.on("exit", (code) => {
+        checkForStartedInstances();
+    });
+    const checkIfNoOtherListenersAndIfSoExit = (signal, code) => {
+        // Check if there is only one listener for this signal which would
+        // imply just us and if so then we need to perform the _default_
+        // act of calling `process.exit()`.
+        if (process.listeners(signal).length === 1) {
+            process.exit(code);
+        }
+    };
+    process.on("SIGTERM", () => {
+        checkForStartedInstances();
+        // NOTE: empirical testing shows that a Node.js process that
+        // exits due to a SIGTERM will exit with a code of 143.
+        checkIfNoOtherListenersAndIfSoExit("SIGTERM", 143);
+    });
+    process.on("SIGINT", () => {
+        checkForStartedInstances();
+        // NOTE: empirical testing shows that a Node.js process that
+        // exits due to a SIGINT will exit with a code of 130.
+        checkIfNoOtherListenersAndIfSoExit("SIGINT", 130);
+    });
 }
 export class Reboot {
     constructor() {
@@ -305,7 +324,7 @@ export class AllowAllIfAuthenticated extends Authorizer {
     }
 }
 export class Application {
-    constructor({ servicers, initialize, tokenVerifier, }) {
+    constructor({ servicers, initialize, initializeBearerToken, tokenVerifier, }) {
         _Application_external.set(this, void 0);
         __classPrivateFieldSet(this, _Application_external, reboot_native.Application_constructor(ExternalContext.fromNativeExternal, servicers, async (context) => {
             if (initialize !== undefined) {
@@ -321,7 +340,7 @@ export class Application {
                     }
                 }
             }
-        }, tokenVerifier), "f");
+        }, initializeBearerToken, tokenVerifier), "f");
     }
     async run() {
         return await reboot_native.Application_run(__classPrivateFieldGet(this, _Application_external, "f"));

package/reboot_native.cc

@@ -1177,13 +1177,11 @@ py::object make_py_token_verifier(NapiSafeObjectReference js_token_verifier) {
                       {Napi::Function::New(
                            env,
                            [py_future](const Napi::CallbackInfo& info) {
-                             Napi::Object js_bytes_auth =
-                                 info[0].As<Napi::Object>();
                              std::optional<std::string> bytes_auth;
-                             if (!js_bytes_auth.IsNull()) {
+                             if (!info[0].IsNull()) {
                                bytes_auth =
                                    uint8array_to_str(
-                                       js_bytes_auth.As<Napi::Uint8Array>());
+                                       info[0].As<Napi::Uint8Array>());
                              }
 
                              adaptor->ScheduleCallbackOnPythonEventLoop(
@@ -1592,7 +1590,7 @@ Napi::Value Service_call(const Napi::CallbackInfo& info) {
 
         py::object py_task =
             py::module::import("reboot.nodejs.python")
-                .attr("create_task")(
+                .attr("create_task_with_context")(
                     py_service->attr(("_" + kind).c_str())(
                         method,
                         py_context,
@@ -1687,7 +1685,7 @@ Napi::Value Future_await(const Napi::CallbackInfo& info) {
        deferred = std::move(deferred)]() {
         py::object py_task =
             py::module::import("reboot.nodejs.python")
-                .attr("create_task")(
+                .attr("create_task_with_context")(
                     py_service->attr("_future_await")(
                         method,
                         py_context,
@@ -1837,9 +1835,14 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
   auto js_initialize = NapiSafeFunctionReference(
       info[2].As<Napi::Function>());
 
+  std::optional<std::string> initialize_bearer_token;
+  if (!info[3].IsUndefined()) {
+    initialize_bearer_token = info[3].As<Napi::String>().Utf8Value();
+  }
+
   std::optional<NapiSafeObjectReference> js_token_verifier;
-  if (info[3].IsObject()) {
-    js_token_verifier = NapiSafeReference(info[3].As<Napi::Object>());
+  if (!info[4].IsUndefined()) {
+    js_token_verifier = NapiSafeReference(info[4].As<Napi::Object>());
   }
 
   std::promise<py::object*> promise;
@@ -1847,6 +1850,7 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
   adaptor->ScheduleCallbackOnPythonEventLoop(
       [&promise,
        servicer_details = std::move(servicer_details),
+       initialize_bearer_token = std::move(initialize_bearer_token),
        js_initialize = std::move(js_initialize),
        js_token_verifier,
        js_from_native_external = std::move(js_from_native_external)]() {
@@ -1943,8 +1947,10 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
               return py_future;
             });
 
-        py::object py_applications = py::module::import(
-            "reboot.aio.applications");
+        py::object py_initialize_bearer_token = py::none();
+        if (initialize_bearer_token.has_value()) {
+          py_initialize_bearer_token = py::str(*initialize_bearer_token);
+        }
 
         py::object py_token_verifier = py::none();
         if (js_token_verifier.has_value()) {
@@ -1952,10 +1958,14 @@ Napi::Value Application_constructor(const Napi::CallbackInfo& info) {
         }
 
         promise.set_value(
-            new py::object(py_applications.attr("Application")(
-                "servicers"_a = py_servicers,
-                "initialize"_a = py_initialize,
-                "token_verifier"_a = py_token_verifier)));
+            new py::object(
+                py::module::import("reboot.aio.applications")
+                    .attr("Application")(
+                        "servicers"_a = py_servicers,
+                        "initialize"_a = py_initialize,
+                        "initialize_bearer_token"_a =
+                            py_initialize_bearer_token,
+                        "token_verifier"_a = py_token_verifier)));
       }
       // TODO(benh): improve error handling mechanism to force all
       // raised exceptions to be handled.
@@ -2016,9 +2026,10 @@ Napi::Value Application_run(const Napi::CallbackInfo& info) {
        py_application,
        deferred = std::move(deferred)]() {
         py::object py_task =
-            py::module::import("asyncio").attr("create_task")(
-                py_application->attr("run")(),
-                "name"_a = "Application.run() in nodejs");
+            py::module::import("reboot.nodejs.python")
+                .attr("create_task")(
+                    py_application->attr("run")(),
+                    "name"_a = "Application.run() in nodejs");
 
         py_task.attr("add_done_callback")(py::cpp_function(
             [deferred = std::move(deferred),
@@ -2041,9 +2052,16 @@ Napi::Value Application_run(const Napi::CallbackInfo& info) {
                     if (!exception.has_value()) {
                       deferred->Resolve(env.Null());
                     } else {
+                      env.Global()
+                          .Get("process")
+                          .As<Napi::Object>()
+                          .Set("exitCode", 1);
                       deferred->Reject(
                           Napi::Error::New(env, *exception).Value());
                     }
+                    // When `Application.run` exits, we unref our
+                    // thread_safe_function to cause the runtime to exit.
+                    adaptor->thread_safe_function.Unref(env);
                   });
 
               delete py_task;
@@ -2340,7 +2358,7 @@ Napi::Value retry_reactively_until(const Napi::CallbackInfo& info) {
 
         py::object py_task =
             py::module::import("reboot.nodejs.python")
-                .attr("create_task")(
+                .attr("create_task_with_context")(
                     (py::module::import("reboot.aio.contexts")
                          .attr("retry_reactively_until"))(
                         py_context,
@@ -2476,7 +2494,7 @@ Napi::Value atLeastOrMostOnce(const Napi::CallbackInfo& info) {
 
         py::object py_task =
             py::module::import("reboot.nodejs.python")
-                .attr("create_task")(
+                .attr("create_task_with_context")(
                     (py::module::import("reboot.aio.memoize").attr("memoize"))(
                         py::str(idempotency_alias),
                         py_context,
@@ -2553,7 +2571,7 @@ Napi::Value Servicer_read(const Napi::CallbackInfo& info) {
        deferred = std::move(deferred)]() {
         py::object py_task =
             py::module::import("reboot.nodejs.python")
-                .attr("create_task")(
+                .attr("create_task_with_context")(
                     py_servicer->attr("_read")(py_context),
                     py_context,
                     "name"_a = "servicer._read(...) in nodejs");
@@ -2702,7 +2720,7 @@ Napi::Value Servicer_write(const Napi::CallbackInfo& info) {
 
         py::object py_task =
             py::module::import("reboot.nodejs.python")
-                .attr("create_task")(
+                .attr("create_task_with_context")(
                     py_servicer->attr("_write")(
                         py_context,
                         py_writer,

package/reboot_native.cjs

@@ -7,7 +7,7 @@ const [major, minor, patch] = process.versions.node.split(".").map(Number);
 
 if (major < 18) {
   console.error(
-    chalk.red(
+    chalk.stderr.bold.red(
       `Reboot requires nodejs version >=18 (found ${major}.${minor}.${patch})`
     )
   );
@@ -16,21 +16,16 @@ if (major < 18) {
 
 const reboot_native = { exports: {} };
 
-// Next.js has its own runtime environment that runs on top of Node. Thus,
-// __dirname isn't correctly defined in a Next.js app.
-// We special case for Next.js for this reason.
-// https://stackoverflow.com/questions/77589486/nextjs-cannot-find-dirname
-// TODO: find a more permanent solution for this.
-let node_modules_reboot_directory;
+// If we are in a Next.js context, check that serverExternalPackages is
+// correctly set. If not correctly set, Reboot backend TS code will not work
+// with React Server Components inside Next.
+
 if (__dirname.includes(".next")) {
-  node_modules_reboot_directory = path.join(
-    process.cwd(),
-    "node_modules",
-    "@reboot-dev",
-    "reboot"
+  throw new Error(
+    "For Next.js to work correctly with Reboot native code, you " +
+      "must include option 'serverExternalPackages: ['@reboot-dev/reboot']' " +
+      "in your next.config.ts"
   );
-} else {
-  node_modules_reboot_directory = __dirname;
 }
 
 // NOTE: as of Python 3.8 we _must_ load the Python library via
@@ -41,12 +36,7 @@ process.dlopen(
   reboot_native,
   // TODO(benh): consider using `require(bindings)` to properly locate
   // 'reboot_native.node'.
-  path.join(
-    node_modules_reboot_directory,
-    "build",
-    "Release",
-    "reboot_native.node"
-  ),
+  path.join(__dirname, "build", "Release", "reboot_native.node"),
   os.constants.dlopen.RTLD_NOW | os.constants.dlopen.RTLD_GLOBAL
 );
 

package/utils/index.d.ts

@@ -1 +1,12 @@
 export * from "./errors.js";
+export declare function parseVersion(version: string): [number, number, number];
+export type Version = [number, number, number];
+export declare function supportedVersion({ required: [requiredMajor, requiredMinor, requiredPatch], found: [foundMajor, foundMinor, foundPatch], }: {
+    required: Version;
+    found: Version;
+}): boolean;
+export declare function ensureYarnNodeLinker(): void;
+/**
+ * Spawn a process with the given arguments, and return its stdout as a string.
+ */
+export declare function spawnAndReturnStdout(command: string, args: string[]): string;

package/utils/index.js

@@ -1 +1,47 @@
+import chalk from "chalk";
+import { spawnSync } from "child_process";
 export * from "./errors.js";
+export function parseVersion(version) {
+    const match = version.trim().match(/(\d+\.\d+\.\d+)/);
+    if (!match) {
+        throw new Error(`Failed to parse '${version}' into a version`);
+    }
+    return version.split(".").map(Number);
+}
+export function supportedVersion({ required: [requiredMajor, requiredMinor, requiredPatch], found: [foundMajor, foundMinor, foundPatch], }) {
+    return (foundMajor > requiredMajor ||
+        (foundMajor === requiredMajor && foundMinor > requiredMinor) ||
+        (foundMajor === requiredMajor &&
+            foundMinor === requiredMinor &&
+            foundPatch >= requiredPatch));
+}
+export function ensureYarnNodeLinker() {
+    // Ensure that they aren't using Yarn Plug'n'Play which we don't yet
+    // support.
+    const nodeLinker = spawnAndReturnStdout("yarn", [
+        "config",
+        "get",
+        "nodeLinker",
+    ]);
+    if (nodeLinker.trim() !== "node-modules") {
+        console.error(chalk.stderr.bold.red("Yarn Plug'n'Play is not yet supported, you must use 'node-modules' as your 'nodeLinker'"));
+        process.exit(-1);
+    }
+}
+/**
+ * Spawn a process with the given arguments, and return its stdout as a string.
+ */
+export function spawnAndReturnStdout(command, args) {
+    const result = spawnSync(command, args, {
+        stdio: ["ignore", "pipe", "inherit"],
+    });
+    if (result.error) {
+        throw new Error(`Failed to run '${command} ${args.join(" ")}': ${result.error}\n` +
+            `\n` +
+            `Please report this bug to the maintainers!`);
+    }
+    else if (result.status !== 0) {
+        throw new Error(`Running '${command} ${args.join(" ")}' exited with status ${result.status}. Please report this bug including the output of that command (if any) to the maintainers!`);
+    }
+    return result.stdout.toString();
+}

package/version.d.ts

@@ -1 +1 @@
-export declare const REBOOT_VERSION = "0.19.0";
+export declare const REBOOT_VERSION = "0.19.2";

package/version.js

@@ -1 +1 @@
-export const REBOOT_VERSION = "0.19.0";
+export const REBOOT_VERSION = "0.19.2";

package/workspaces.js

@@ -0,0 +1,120 @@
+import whichPMRuns from "which-pm-runs";
+import { parseVersion, spawnAndReturnStdout, supportedVersion, } from "./utils/index.js";
+/**
+ * Returns package-manager Workspaces of which a project in the given directory
+ * is a member.
+ */
+export async function locateWorkspaces() {
+    const packageManager = await whichPMRuns();
+    if (!packageManager) {
+        return null;
+    }
+    // NOTE: These methods will error if they fail to extract
+    // workspaces, based on the assumption that `whichPMRuns` will do a
+    // reasonable job of detecting a package manager, otherwise throws
+    // an exception.
+    switch (packageManager.name) {
+        case "yarn": {
+            return extractYarnWorkspaces();
+        }
+        case "npm": {
+            return extractNpmWorkspaces();
+        }
+        case "pnpm": {
+            return extractPnpmWorkspaces();
+        }
+        default: {
+            throw new Error(`Unsupported package manager '${packageManager}'`);
+        }
+    }
+}
+function extractYarnWorkspaces() {
+    // TODO: what is the actual minimum version we need?
+    const YARN_VERSION_REQUIRED = "4.0.0";
+    const required = parseVersion(YARN_VERSION_REQUIRED);
+    const found = parseVersion(spawnAndReturnStdout("yarn", ["--version"]));
+    if (!supportedVersion({ required, found })) {
+        throw new Error(`yarn version >=${YARN_VERSION_REQUIRED} is required, found ${found.join(".")}`);
+    }
+    const command = "yarn";
+    const args = ["workspaces", "list", "--json", "--recursive"];
+    // `yarn workspaces list --json` returns JSON lines, not complete
+    // JSON, so we have to do some extra parsing ourselves.
+    return spawnAndReturnStdout(command, args)
+        .trim()
+        .split("\n")
+        .map((line) => {
+        const { name } = JSON.parse(line.trim());
+        return { name };
+    });
+}
+function extractNpmWorkspaces() {
+    // We need >=8.16.0 which is when `npm query` was introduced.
+    const NPM_VERSION_REQUIRED = "8.16.0";
+    const required = parseVersion(NPM_VERSION_REQUIRED);
+    const found = parseVersion(spawnAndReturnStdout("npm", ["--version"]));
+    if (!supportedVersion({ required, found })) {
+        throw new Error(`npm version >=${NPM_VERSION_REQUIRED} is required, found ${found.join(".")}`);
+    }
+    const command = "npm";
+    const args = ["query", ".workspace"];
+    const workspaces = spawnAndParseJSON(command, args).map(({ name }) => ({
+        name,
+    }));
+    // Include the package name as it might be used and it is consistent
+    // with both `yarn` and `pnpm` which always include the top-level
+    // package name even if they aren't explicitly in `workspaces`.
+    const name = spawnAndParseJSON("npm", ["pkg", "get", "name"]);
+    // `npm pkg get name` returns an empty object if there is no
+    // top-level package name.
+    if (Object.keys(name).length === 0) {
+        return workspaces;
+    }
+    else if (typeof name !== "string") {
+        throw new Error(`Failed to get name of your package. Please report this issue to the maintainers!`);
+    }
+    return [{ name }, ...workspaces];
+}
+function extractPnpmWorkspaces() {
+    // TODO: is there a minimum version required?
+    const command = "pnpm";
+    const args = ["list", "--recursive", "--depth", "-1", "--only-projects"];
+    // `pnpm list --recursive --depth -1 --only-projects --json` emits something
+    // which is not quite valid JSON: closer to JSON lines, but not easily splittable.
+    //
+    // Instead, we parse the human-readable output -- a series of lines like:
+    //    @reboot-pm/prosemirror@0.0.1 /Users/example/src/repo_root/project_dir (PRIVATE)
+    return spawnAndReturnStdout(command, args)
+        .trim()
+        .split("\n")
+        .map((line) => {
+        const parts = line.trim().split(" ");
+        if (parts.length !== 3) {
+            throw new Error(`Unexpected output from '${command} ${args.join(" ")}'. Please report the output of that command to the maintainers!`);
+        }
+        // Strip off the version from the name.
+        const lastAtSign = parts[0].lastIndexOf("@");
+        let name;
+        if (lastAtSign !== -1 && lastAtSign !== 0) {
+            name = parts[0].substring(0, lastAtSign);
+        }
+        else {
+            name = parts[0];
+        }
+        return { name };
+    });
+}
+/**
+ * Spawn a process with the given arguments, and parse its stdout as JSON.
+ *
+ * Raises an error if the process cannot be spawned, or if JSON cannot be parsed.
+ */
+function spawnAndParseJSON(command, args) {
+    const stdout = spawnAndReturnStdout(command, args);
+    try {
+        return JSON.parse(stdout);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse output of '${command} ${args.join(" ")}' as JSON: ${error}`);
+    }
+}