@cedarjs/cli 0.0.4

package/dist/commands/type-checkHandler.js

@@ -0,0 +1,71 @@
+import path from "path";
+import concurrently from "concurrently";
+import execa from "execa";
+import { Listr } from "listr2";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getCmdMajorVersion } from "../commands/upgrade.js";
+import { generatePrismaClient } from "../lib/generatePrismaClient.js";
+import { getPaths } from "../lib/index.js";
+const handler = async ({ sides, verbose, prisma, generate }) => {
+  recordTelemetryAttributes({
+    command: "type-check",
+    sides: JSON.stringify(sides),
+    verbose,
+    prisma,
+    generate
+  });
+  const typeCheck = async () => {
+    let conclusiveExitCode = 0;
+    const yarnVersion = await getCmdMajorVersion("yarn");
+    const tscForAllSides = sides.map((side) => {
+      const projectDir = path.join(getPaths().base, side);
+      return {
+        cwd: projectDir,
+        command: `yarn ${yarnVersion > 1 ? "" : "-s"} tsc --noEmit --skipLibCheck`
+      };
+    });
+    const { result } = concurrently(tscForAllSides, {
+      group: true,
+      raw: true
+    });
+    try {
+      await result;
+    } catch (err) {
+      if (err.length) {
+        const exitCodes = err.map((e) => e?.exitCode).filter(Boolean);
+        conclusiveExitCode = Math.max(...exitCodes);
+      }
+    }
+    return conclusiveExitCode;
+  };
+  if (generate && prisma) {
+    await generatePrismaClient({
+      verbose,
+      schema: getPaths().api.dbSchema
+    });
+  }
+  if (generate) {
+    await new Listr(
+      [
+        {
+          title: "Generating types",
+          task: () => execa("yarn rw-gen", {
+            shell: true,
+            stdio: verbose ? "inherit" : "ignore"
+          })
+        }
+      ],
+      {
+        renderer: verbose && "verbose",
+        rendererOptions: { collapseSubtasks: false }
+      }
+    ).run();
+  }
+  const exitCode = await typeCheck();
+  if (exitCode > 0) {
+    process.exitCode = exitCode;
+  }
+};
+export {
+  handler
+};

package/dist/commands/upgrade.js

@@ -0,0 +1,441 @@
+import path from "path";
+import execa from "execa";
+import fs from "fs-extra";
+import latestVersion from "latest-version";
+import { Listr } from "listr2";
+import terminalLink from "terminal-link";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { getConfig } from "@cedarjs/project-config";
+import c from "../lib/colors.js";
+import { generatePrismaClient } from "../lib/generatePrismaClient.js";
+import { getPaths } from "../lib/index.js";
+import { PLUGIN_CACHE_FILENAME } from "../lib/plugin.js";
+const command = "upgrade";
+const description = "Upgrade all @cedarjs packages via interactive CLI";
+const builder = (yargs) => {
+  yargs.example(
+    "rw upgrade -t 0.20.1-canary.5",
+    "Specify a version. URL for Version History:\nhttps://www.npmjs.com/package/@cedarjs/core"
+  ).option("dry-run", {
+    alias: "d",
+    description: "Check for outdated packages without upgrading",
+    type: "boolean"
+  }).option("tag", {
+    alias: "t",
+    description: '[choices: "latest", "rc", "next", "canary", "experimental", or a specific-version (see example below)] WARNING: "canary", "rc" and "experimental" are unstable releases! And "canary" releases include breaking changes often requiring codemods if upgrading a project.',
+    requiresArg: true,
+    type: "string",
+    coerce: validateTag
+  }).option("verbose", {
+    alias: "v",
+    description: "Print verbose logs",
+    type: "boolean",
+    default: false
+  }).option("dedupe", {
+    description: "Skip dedupe check with --no-dedupe",
+    type: "boolean",
+    default: true
+  }).epilogue(
+    `Also see the ${terminalLink(
+      "Cedar CLI Reference for the upgrade command",
+      "https://redwoodjs.com/docs/cli-commands#upgrade"
+    )}.
+And the ${terminalLink(
+      "GitHub releases page",
+      "https://github.com/cedarjs/cedar/releases"
+    )} for more information on the current release.`
+  );
+};
+const SEMVER_REGEX = /(?<=^v?|\sv?)(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|[\da-z-]*[a-z-][\da-z-]*)(?:\.(?:0|[1-9]\d*|[\da-z-]*[a-z-][\da-z-]*))*)?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?(?=$|\s)/i;
+const isValidSemver = (string) => {
+  return SEMVER_REGEX.test(string);
+};
+const isValidCedarTag = (tag) => {
+  return ["rc", "canary", "latest", "next", "experimental"].includes(tag);
+};
+const validateTag = (tag) => {
+  const isTagValid = isValidSemver(tag) || isValidCedarTag(tag);
+  if (!isTagValid) {
+    throw new Error(
+      c.error(
+        "Invalid tag supplied. Supported values: 'rc', 'canary', 'latest', 'next', 'experimental', or a valid semver version\n"
+      )
+    );
+  }
+  return tag;
+};
+const handler = async ({ dryRun, tag, verbose, dedupe }) => {
+  recordTelemetryAttributes({
+    command: "upgrade",
+    dryRun,
+    tag,
+    verbose,
+    dedupe
+  });
+  const tasks = new Listr(
+    [
+      {
+        title: "Checking latest version",
+        task: async (ctx) => setLatestVersionToContext(ctx, tag)
+      },
+      {
+        title: "Updating your Cedar version",
+        task: (ctx) => updateCedarDepsForAllSides(ctx, { dryRun, verbose }),
+        enabled: (ctx) => !!ctx.versionToUpgradeTo
+      },
+      {
+        title: "Updating other packages in your package.json(s)",
+        task: (ctx) => updatePackageVersionsFromTemplate(ctx, { dryRun, verbose }),
+        enabled: (ctx) => ctx.versionToUpgradeTo?.includes("canary")
+      },
+      {
+        title: "Downloading yarn patches",
+        task: (ctx) => downloadYarnPatches(ctx, { dryRun, verbose }),
+        enabled: (ctx) => ctx.versionToUpgradeTo?.includes("canary")
+      },
+      {
+        title: "Removing CLI cache",
+        task: (ctx) => removeCliCache(ctx, { dryRun, verbose })
+      },
+      {
+        title: "Running yarn install",
+        task: (ctx) => yarnInstall(ctx, { dryRun, verbose }),
+        skip: () => dryRun
+      },
+      {
+        title: "Refreshing the Prisma client",
+        task: (_ctx, task) => refreshPrismaClient(task, { verbose }),
+        skip: () => dryRun
+      },
+      {
+        title: "De-duplicating dependencies",
+        skip: () => dryRun || !dedupe,
+        task: (_ctx, task) => dedupeDeps(task, { verbose })
+      },
+      {
+        title: "One more thing..",
+        task: (ctx, task) => {
+          const version = ctx.versionToUpgradeTo;
+          const messageSections = [
+            `One more thing...
+
+   ${c.warning(
+              `\u{1F389} Your project has been upgraded to Cedar ${version}!`
+            )} 
+
+`
+          ];
+          if ([void 0, "latest", "rc"].includes(tag)) {
+            messageSections.push(
+              `   Please review the release notes for any manual steps: 
+   \u2756 ${terminalLink(
+                `Redwood community discussion`,
+                `https://community.redwoodjs.com/c/announcements/releases-and-upgrade-guides/`
+              )}
+   \u2756 ${terminalLink(
+                `GitHub Release notes`,
+                `https://github.com/cedarjs/cedar/releases`
+                // intentionally not linking to specific version
+              )} 
+
+`
+            );
+          }
+          if (tag) {
+            const additionalMessages = [];
+            if (!getConfig().notifications.versionUpdates.includes(tag) && isValidCedarTag(tag)) {
+              additionalMessages.push(
+                `   \u2756 You may want to update your redwood.toml config so that \`notifications.versionUpdates\` includes "${tag}"
+`
+              );
+            }
+            if (additionalMessages.length > 0) {
+              messageSections.push(
+                `   \u{1F4E2} ${c.warning(`We'd also like to remind you that:`)} 
+`,
+                ...additionalMessages
+              );
+            }
+          }
+          task.title = messageSections.join("").trimEnd();
+        }
+      }
+    ],
+    {
+      renderer: verbose && "verbose",
+      rendererOptions: { collapseSubtasks: false }
+    }
+  );
+  await tasks.run();
+};
+async function yarnInstall({ verbose }) {
+  const yarnVersion = await getCmdMajorVersion("yarn");
+  try {
+    await execa(
+      "yarn install",
+      yarnVersion > 1 ? [] : ["--force", "--non-interactive"],
+      {
+        shell: true,
+        stdio: verbose ? "inherit" : "pipe",
+        cwd: getPaths().base
+      }
+    );
+  } catch (e) {
+    throw new Error(
+      "Could not finish installation. Please run `yarn install` and then `yarn dedupe`, before continuing"
+    );
+  }
+}
+async function removeCliCache(ctx, { dryRun, verbose }) {
+  const cliCacheDir = path.join(
+    getPaths().generated.base,
+    PLUGIN_CACHE_FILENAME
+  );
+  if (verbose) {
+    console.log("Removing CLI cache at: ", cliCacheDir);
+  }
+  if (!dryRun) {
+    fs.removeSync(cliCacheDir);
+  }
+}
+async function setLatestVersionToContext(ctx, tag) {
+  try {
+    const foundVersion = await latestVersion(
+      "@cedarjs/core",
+      tag ? { version: tag } : {}
+    );
+    ctx.versionToUpgradeTo = foundVersion;
+    return foundVersion;
+  } catch (e) {
+    if (tag) {
+      throw new Error("Could not find the latest `" + tag + "` version");
+    }
+    throw new Error("Could not find the latest version");
+  }
+}
+function updatePackageJsonVersion(pkgPath, version, { dryRun, verbose }) {
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(pkgPath, "package.json"), "utf-8")
+  );
+  if (pkg.dependencies) {
+    for (const depName of Object.keys(pkg.dependencies).filter(
+      (x) => x.startsWith("@cedarjs/") && x !== "@cedarjs/studio"
+    )) {
+      if (verbose || dryRun) {
+        console.log(` - ${depName}: ${pkg.dependencies[depName]} => ${version}`);
+      }
+      pkg.dependencies[depName] = `${version}`;
+    }
+  }
+  if (pkg.devDependencies) {
+    for (const depName of Object.keys(pkg.devDependencies).filter(
+      (x) => x.startsWith("@cedarjs/") && x !== "@cedarjs/studio"
+    )) {
+      if (verbose || dryRun) {
+        console.log(
+          ` - ${depName}: ${pkg.devDependencies[depName]} => ${version}`
+        );
+      }
+      pkg.devDependencies[depName] = `${version}`;
+    }
+  }
+  if (!dryRun) {
+    fs.writeFileSync(
+      path.join(pkgPath, "package.json"),
+      JSON.stringify(pkg, void 0, 2)
+    );
+  }
+}
+function updateCedarDepsForAllSides(ctx, options) {
+  if (!ctx.versionToUpgradeTo) {
+    throw new Error("Failed to upgrade");
+  }
+  const updatePaths = [
+    getPaths().base,
+    getPaths().api.base,
+    getPaths().web.base
+  ];
+  return new Listr(
+    updatePaths.map((basePath) => {
+      const pkgJsonPath = path.join(basePath, "package.json");
+      return {
+        title: `Updating ${pkgJsonPath}`,
+        task: () => updatePackageJsonVersion(basePath, ctx.versionToUpgradeTo, options),
+        skip: () => !fs.existsSync(pkgJsonPath)
+      };
+    })
+  );
+}
+async function updatePackageVersionsFromTemplate(ctx, { dryRun, verbose }) {
+  if (!ctx.versionToUpgradeTo) {
+    throw new Error("Failed to upgrade");
+  }
+  const packageJsons = [
+    {
+      basePath: getPaths().base,
+      url: "https://raw.githubusercontent.com/cedarjs/cedar/main/packages/create-cedar-app/templates/ts/package.json"
+    },
+    {
+      basePath: getPaths().api.base,
+      url: "https://raw.githubusercontent.com/cedarjs/cedar/main/packages/create-cedar-app/templates/ts/api/package.json"
+    },
+    {
+      basePath: getPaths().web.base,
+      url: "https://raw.githubusercontent.com/cedarjs/cedar/main/packages/create-cedar-app/templates/ts/web/package.json"
+    }
+  ];
+  return new Listr(
+    packageJsons.map(({ basePath, url }) => {
+      const pkgJsonPath = path.join(basePath, "package.json");
+      return {
+        title: `Updating ${pkgJsonPath}`,
+        task: async () => {
+          const res = await fetch(url);
+          const text = await res.text();
+          const templatePackageJson = JSON.parse(text);
+          const localPackageJsonText = fs.readFileSync(pkgJsonPath, "utf-8");
+          const localPackageJson = JSON.parse(localPackageJsonText);
+          Object.entries(templatePackageJson.dependencies || {}).forEach(
+            ([depName, depVersion]) => {
+              if (!depName.startsWith("@cedarjs/")) {
+                if (verbose || dryRun) {
+                  console.log(
+                    ` - ${depName}: ${localPackageJson.dependencies[depName]} => ${depVersion}`
+                  );
+                }
+                localPackageJson.dependencies[depName] = depVersion;
+              }
+            }
+          );
+          Object.entries(templatePackageJson.devDependencies || {}).forEach(
+            ([depName, depVersion]) => {
+              if (!depName.startsWith("@cedarjs/")) {
+                if (verbose || dryRun) {
+                  console.log(
+                    ` - ${depName}: ${localPackageJson.devDependencies[depName]} => ${depVersion}`
+                  );
+                }
+                localPackageJson.devDependencies[depName] = depVersion;
+              }
+            }
+          );
+          if (!dryRun) {
+            fs.writeFileSync(
+              pkgJsonPath,
+              JSON.stringify(localPackageJson, null, 2)
+            );
+          }
+        },
+        skip: () => !fs.existsSync(pkgJsonPath)
+      };
+    })
+  );
+}
+async function downloadYarnPatches(ctx, { dryRun, verbose }) {
+  if (!ctx.versionToUpgradeTo) {
+    throw new Error("Failed to upgrade");
+  }
+  const githubToken = process.env.GH_TOKEN || process.env.GITHUB_TOKEN || process.env.REDWOOD_GITHUB_TOKEN;
+  const res = await fetch(
+    "https://api.github.com/repos/cedarjs/cedar/git/trees/main?recursive=1",
+    {
+      headers: {
+        Authorization: githubToken ? `Bearer ${githubToken}` : void 0,
+        ["X-GitHub-Api-Version"]: "2022-11-28",
+        Accept: "application/vnd.github+json"
+      }
+    }
+  );
+  const json = await res.json();
+  const patches = json.tree?.filter(
+    (patchInfo) => patchInfo.path.startsWith(
+      "packages/create-cedar-app/templates/ts/.yarn/patches/"
+    )
+  );
+  const patchDir = path.join(getPaths().base, ".yarn", "patches");
+  if (verbose) {
+    console.log("Creating patch directory", patchDir);
+  }
+  if (!dryRun) {
+    fs.mkdirSync(patchDir, { recursive: true });
+  }
+  return new Listr(
+    (patches || []).map((patch) => {
+      return {
+        title: `Downloading ${patch.path}`,
+        task: async () => {
+          const res2 = await fetch(patch.url);
+          const patchMeta = await res2.json();
+          const patchPath = path.join(
+            getPaths().base,
+            ".yarn",
+            "patches",
+            path.basename(patch.path)
+          );
+          if (verbose) {
+            console.log("Writing patch", patchPath);
+          }
+          if (!dryRun) {
+            await fs.writeFile(patchPath, patchMeta.content, "base64");
+          }
+        }
+      };
+    })
+  );
+}
+async function refreshPrismaClient(task, { verbose }) {
+  try {
+    await generatePrismaClient({
+      verbose,
+      force: false,
+      schema: getPaths().api.dbSchema
+    });
+  } catch (e) {
+    task.skip("Refreshing the Prisma client caused an Error.");
+    console.log(
+      "You may need to update your prisma client manually: $ yarn rw prisma generate"
+    );
+    console.log(c.error(e.message));
+  }
+}
+const getCmdMajorVersion = async (command2) => {
+  const { stdout } = await execa(command2, ["--version"], {
+    cwd: getPaths().base
+  });
+  if (!SEMVER_REGEX.test(stdout)) {
+    throw new Error(`Unable to verify ${command2} version.`);
+  }
+  const version = stdout.match(SEMVER_REGEX)[0];
+  return parseInt(version.split(".")[0]);
+};
+const dedupeDeps = async (task, { verbose }) => {
+  try {
+    const yarnVersion = await getCmdMajorVersion("yarn");
+    const baseExecaArgsForDedupe = {
+      shell: true,
+      stdio: verbose ? "inherit" : "pipe",
+      cwd: getPaths().base
+    };
+    if (yarnVersion > 1) {
+      await execa("yarn", ["dedupe"], baseExecaArgsForDedupe);
+    } else {
+      task.skip(
+        "Yarn 1.x doesn't support dedupe directly. Please upgrade yarn or use npx with `npx yarn-deduplicate` manually."
+      );
+    }
+  } catch (e) {
+    console.log(c.error(e.message));
+    throw new Error(
+      "Could not finish de-duplication. For yarn 1.x, please run `npx yarn-deduplicate`, or for yarn >= 3 run `yarn dedupe` before continuing"
+    );
+  }
+  await yarnInstall({ verbose });
+};
+export {
+  builder,
+  command,
+  description,
+  getCmdMajorVersion,
+  handler,
+  validateTag
+};

package/dist/index.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import path from "path";
+import { trace, SpanStatusCode } from "@opentelemetry/api";
+import fs from "fs-extra";
+import { hideBin, Parser } from "yargs/helpers";
+import yargs from "yargs/yargs";
+import { loadEnvFiles, recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { telemetryMiddleware } from "@cedarjs/telemetry";
+import * as buildCommand from "./commands/build.js";
+import * as checkCommand from "./commands/check.js";
+import * as consoleCommand from "./commands/console.js";
+import * as deployCommand from "./commands/deploy.js";
+import * as destroyCommand from "./commands/destroy.js";
+import * as devCommand from "./commands/dev.js";
+import * as execCommand from "./commands/exec.js";
+import * as experimentalCommand from "./commands/experimental.js";
+import * as generateCommand from "./commands/generate.js";
+import * as infoCommand from "./commands/info.js";
+import * as jobsCommand from "./commands/jobs.js";
+import * as lintCommand from "./commands/lint.js";
+import * as prerenderCommand from "./commands/prerender.js";
+import * as prismaCommand from "./commands/prisma.js";
+import * as recordCommand from "./commands/record.js";
+import * as serveCommand from "./commands/serve.js";
+import * as setupCommand from "./commands/setup.js";
+import * as studioCommand from "./commands/studio.js";
+import * as testCommand from "./commands/test.js";
+import * as tstojsCommand from "./commands/ts-to-js.js";
+import * as typeCheckCommand from "./commands/type-check.js";
+import * as upgradeCommand from "./commands/upgrade.js";
+import { exitWithError } from "./lib/exit.js";
+import { findUp } from "./lib/index.js";
+import * as updateCheck from "./lib/updateCheck.js";
+import { loadPlugins } from "./plugin.js";
+import { startTelemetry, shutdownTelemetry } from "./telemetry/index.js";
+let { cwd, telemetry, help, version } = Parser(hideBin(process.argv), {
+  // Telemetry is enabled by default, but can be disabled in two ways
+  // - by passing a `--telemetry false` option
+  // - by setting a `REDWOOD_DISABLE_TELEMETRY` env var
+  boolean: ["telemetry"],
+  default: {
+    telemetry: process.env.REDWOOD_DISABLE_TELEMETRY === void 0 || process.env.REDWOOD_DISABLE_TELEMETRY === ""
+  }
+});
+cwd ??= process.env.RWJS_CWD;
+try {
+  if (cwd) {
+    if (!fs.existsSync(path.join(cwd, "redwood.toml"))) {
+      throw new Error(`Couldn't find a "redwood.toml" file in ${cwd}`);
+    }
+  } else {
+    const redwoodTOMLPath = findUp("redwood.toml");
+    if (!redwoodTOMLPath) {
+      throw new Error(
+        `Couldn't find up a "redwood.toml" file from ${process.cwd()}`
+      );
+    }
+    cwd = path.dirname(redwoodTOMLPath);
+  }
+} catch (error) {
+  console.error(error.message);
+  process.exit(1);
+}
+process.env.RWJS_CWD = cwd;
+if (process.cwd() !== cwd) {
+  process.chdir(cwd);
+}
+loadEnvFiles();
+async function main() {
+  if (telemetry) {
+    startTelemetry();
+  }
+  const tracer = trace.getTracer("redwoodjs");
+  await tracer.startActiveSpan("cli", async (span) => {
+    const telemetryTimeoutTimer = setTimeout(() => {
+      shutdownTelemetry();
+    }, 5 * 6e4);
+    if (version) {
+      recordTelemetryAttributes({ command: "--version" });
+    }
+    if (help) {
+      recordTelemetryAttributes({ command: "--help" });
+    }
+    try {
+      await runYargs();
+    } catch (error) {
+      exitWithError(error);
+    }
+    if (span?.isRecording()) {
+      span?.setStatus({ code: SpanStatusCode.OK });
+      span?.end();
+    }
+    clearTimeout(telemetryTimeoutTimer);
+  });
+  if (telemetry) {
+    shutdownTelemetry();
+  }
+}
+async function runYargs() {
+  const yarg = yargs(hideBin(process.argv)).scriptName("rw").middleware(
+    [
+      // We've already handled `cwd` above, but it may still be in `argv`.
+      // We don't need it anymore so let's get rid of it.
+      // Likewise for `telemetry`.
+      (argv) => {
+        delete argv.cwd;
+        delete argv.addEnvFiles;
+        delete argv["load-env-files"];
+        delete argv.telemetry;
+      },
+      telemetry && telemetryMiddleware,
+      updateCheck.isEnabled() && updateCheck.updateCheckMiddleware
+    ].filter(Boolean)
+  ).option("cwd", {
+    describe: "Working directory to use (where `redwood.toml` is located)"
+  }).option("load-env-files", {
+    describe: "Load additional .env files. Values defined in files specified later override earlier ones.",
+    array: true
+  }).example(
+    "yarn rw exec migrateUsers --load-env-files stripe nakama",
+    "Run a script, also loading env vars from '.env.stripe' and '.env.nakama'"
+  ).option("telemetry", {
+    describe: "Whether to send anonymous usage telemetry to RedwoodJS",
+    boolean: true
+    // hidden: true,
+  }).example(
+    "yarn rw g page home /",
+    "Create a page component named 'Home' at path '/'"
+  ).demandCommand().strict().exitProcess(false).alias("h", "help").command(buildCommand).command(checkCommand).command(consoleCommand).command(deployCommand).command(destroyCommand).command(devCommand).command(execCommand).command(experimentalCommand).command(generateCommand).command(infoCommand).command(jobsCommand).command(lintCommand).command(prerenderCommand).command(prismaCommand).command(recordCommand).command(serveCommand).command(setupCommand).command(studioCommand).command(testCommand).command(tstojsCommand).command(typeCheckCommand).command(upgradeCommand);
+  await loadPlugins(yarg);
+  const pkgJson = await import("../package.json", { with: { type: "json" } });
+  yarg.version(pkgJson.default["version"]);
+  await yarg.parse(process.argv.slice(2), {}, (err, _argv, output) => {
+    if (err) {
+      process.exitCode = 1;
+    }
+    if (output) {
+      if (err) {
+        console.error(output);
+      } else {
+        console.log(output);
+      }
+    }
+  });
+}
+main();

package/dist/lib/background.js

@@ -0,0 +1,45 @@
+import { spawn } from "child_process";
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import { getPaths } from "@cedarjs/project-config";
+function spawnBackgroundProcess(name, cmd, args) {
+  const logDirectory = path.join(getPaths().generated.base, "logs");
+  fs.ensureDirSync(logDirectory);
+  const safeName = name.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+  const logHeader = [
+    `Starting log:`,
+    ` - Time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    ` - Name: ${name} (${safeName})`,
+    ` - Command: ${cmd}`,
+    ` - Arguments: ${args.join(" ")}`,
+    "",
+    ""
+  ].join("\n");
+  const stdout = fs.openSync(
+    path.join(logDirectory, `${safeName}.out.log`),
+    "w"
+  );
+  fs.writeSync(stdout, logHeader);
+  const stderr = fs.openSync(
+    path.join(logDirectory, `${safeName}.err.log`),
+    "w"
+  );
+  fs.writeSync(stderr, logHeader);
+  const spawnOptions = os.type() === "Windows_NT" ? {
+    // The following options run the process in the background without a console window, even though they don't look like they would.
+    // See https://github.com/nodejs/node/issues/21825#issuecomment-503766781 for information
+    detached: false,
+    windowsHide: false,
+    shell: true,
+    stdio: ["ignore", stdout, stderr]
+  } : {
+    detached: true,
+    stdio: ["ignore", stdout, stderr]
+  };
+  const child = spawn(cmd, args, spawnOptions);
+  child.unref();
+}
+export {
+  spawnBackgroundProcess
+};