@create-node-app/core 0.0.0

package/dist/index.js

@@ -0,0 +1,867 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var create_node_app_core_exports = {};
+__export(create_node_app_core_exports, {
+  createNodeApp: () => createNodeApp,
+  printEnvInfo: () => printEnvInfo
+});
+module.exports = __toCommonJS(create_node_app_core_exports);
+var import_chalk4 = __toESM(require("chalk"));
+var import_envinfo = __toESM(require("envinfo"));
+
+// installer.ts
+var import_underscore2 = __toESM(require("underscore"));
+var import_path4 = __toESM(require("path"));
+var import_fs5 = __toESM(require("fs"));
+var import_chalk3 = __toESM(require("chalk"));
+var import_os3 = __toESM(require("os"));
+var import_semver2 = __toESM(require("semver"));
+var import_cross_spawn2 = __toESM(require("cross-spawn"));
+var import_child_process3 = require("child_process");
+
+// helpers.ts
+var import_child_process = require("child_process");
+var import_cross_spawn = __toESM(require("cross-spawn"));
+var import_chalk = __toESM(require("chalk"));
+var import_semver = __toESM(require("semver"));
+var import_dns = __toESM(require("dns"));
+var import_url = require("url");
+var shouldUseYarn = () => {
+  try {
+    (0, import_child_process.execSync)("yarnpkg --version", { stdio: "ignore" });
+    return true;
+  } catch (e) {
+    console.log(e);
+    return false;
+  }
+};
+var checkThatNpmCanReadCwd = () => {
+  const cwd = process.cwd();
+  let childOutput = null;
+  try {
+    childOutput = import_cross_spawn.default.sync("npm", ["config", "list"]).output.join("");
+  } catch (err) {
+    return true;
+  }
+  if (typeof childOutput !== "string") {
+    return true;
+  }
+  const lines = childOutput.split("\n");
+  const prefix = " cwd = ";
+  const line = lines.find((l) => l.indexOf(prefix) === 0);
+  if (typeof line !== "string") {
+    return true;
+  }
+  const npmCWD = line.substring(prefix.length);
+  if (npmCWD === cwd) {
+    return true;
+  }
+  console.error(
+    import_chalk.default.red(
+      `Could not start an npm process in the right directory.
+
+The current directory is: ${import_chalk.default.bold(cwd)}
+However, a newly started npm process runs in: ${import_chalk.default.bold(
+        npmCWD
+      )}
+
+This is probably caused by a misconfigured system terminal shell.`
+    )
+  );
+  if (process.platform === "win32") {
+    console.error(
+      import_chalk.default.red(`On Windows, this can usually be fixed by running:
+
+`) + `  ${import_chalk.default.cyan(
+        "reg"
+      )} delete "HKCU\\Software\\Microsoft\\Command Processor" /v AutoRun /f
+  ${import_chalk.default.cyan(
+        "reg"
+      )} delete "HKLM\\Software\\Microsoft\\Command Processor" /v AutoRun /f
+
+` + import_chalk.default.red(`Try to run the above two lines in the terminal.
+`) + import_chalk.default.red(
+        `To learn more about this problem, read: https://blogs.msdn.microsoft.com/oldnewthing/20071121-00/?p=24433/`
+      )
+    );
+  }
+  return false;
+};
+var checkNpmVersion = () => {
+  let hasMinNpm = false;
+  let npmVersion = void 0;
+  try {
+    npmVersion = (0, import_child_process.execSync)("npm --version").toString().trim();
+    hasMinNpm = import_semver.default.gte(npmVersion, "3.0.0");
+  } catch (err) {
+  }
+  return {
+    hasMinNpm,
+    npmVersion
+  };
+};
+var getProxy = () => {
+  if (process.env.HTTPS_PROXY) {
+    return process.env.HTTPS_PROXY;
+  }
+  try {
+    const httpsProxy = (0, import_child_process.execSync)("npm config get https-proxy").toString().trim();
+    return httpsProxy !== "null" ? httpsProxy : void 0;
+  } catch (e) {
+  }
+  return "";
+};
+var checkIfOnline = (useYarn) => {
+  if (!useYarn) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve) => {
+    import_dns.default.lookup("registry.yarnpkg.com", (err) => {
+      let proxy;
+      if (err != null && (proxy = getProxy())) {
+        import_dns.default.lookup(new import_url.URL(proxy).hostname, (proxyErr) => {
+          resolve(!proxyErr);
+        });
+      } else {
+        resolve(!err);
+      }
+    });
+  });
+};
+
+// package.ts
+var import_fs3 = require("fs");
+var import_lodash = __toESM(require("lodash.merge"));
+
+// paths.ts
+var import_fs2 = __toESM(require("fs"));
+var import_os2 = __toESM(require("os"));
+var import_path2 = __toESM(require("path"));
+
+// git.ts
+var import_os = __toESM(require("os"));
+var import_child_process2 = __toESM(require("child_process"));
+var import_path = __toESM(require("path"));
+var import_util = require("util");
+var import_fs = __toESM(require("fs"));
+var import_download = __toESM(require("download"));
+var import_debug = __toESM(require("debug"));
+var log = (0, import_debug.default)("cna:git");
+var exec = (0, import_util.promisify)(import_child_process2.default.exec);
+var filterGit = (src) => {
+  return !/(\\|\/)\.git\b/.test(src);
+};
+var clone = (git, target, branch) => {
+  const command = ["git", "clone", "--depth=1", "-b", branch, git, target];
+  return exec(command.join(" "));
+};
+var pull = async (cwd) => {
+  await exec("git checkout -f", { cwd });
+  await exec("git pull", { cwd });
+};
+var downloadRepository = async ({
+  git = "",
+  zip,
+  offline = false,
+  target = "./",
+  branch = "main",
+  way = "git",
+  targetId,
+  cacheDir: optsCacheDir
+}) => {
+  const absoluteTarget = import_path.default.isAbsolute(target) ? target : import_path.default.resolve(target);
+  const isGithub = /^[^/]+\/[^/]+$/.test(git);
+  const gitUrl = isGithub ? `https://github.com/${git}` : git;
+  const zipUrl = isGithub ? `https://github.com/${git}/archive/${branch}.zip` : zip;
+  const id = targetId || Buffer.from(`${git}@${branch}`).toString("base64");
+  let cacheDir = optsCacheDir || import_path.default.join(import_os.default.homedir(), ".cache", "cna", id);
+  cacheDir = import_path.default.isAbsolute(cacheDir) ? cacheDir : import_path.default.resolve(cacheDir);
+  log("cache folder: %s", cacheDir);
+  log("git url: %s", gitUrl);
+  log("zip url: %s", zipUrl);
+  const cached = import_fs.default.existsSync(cacheDir);
+  const createByGit = async () => {
+    log("git mode");
+    if (!cached) {
+      if (!gitUrl) {
+        throw new Error(
+          `Expect parameter opts.git when opts.way is 'git', but got ${gitUrl}`
+        );
+      }
+      await clone(gitUrl, cacheDir, branch);
+    }
+    if (offline) {
+      import_fs.default.cpSync(cacheDir, absoluteTarget, {
+        force: true,
+        filter: filterGit,
+        recursive: true
+      });
+      return;
+    }
+    await pull(cacheDir);
+    setTimeout(() => {
+      import_fs.default.cpSync(cacheDir, absoluteTarget, {
+        force: true,
+        filter: filterGit,
+        recursive: true
+      });
+    }, 400);
+  };
+  const createByZip = async () => {
+    log("zip mode");
+    if (!zipUrl) {
+      throw new Error(
+        `Expect parameter opts.zip when opts.way is 'zip', but got ${zipUrl}`
+      );
+    }
+    await (0, import_download.default)(zipUrl, target, { extract: true });
+  };
+  switch (way) {
+    case "git":
+      return createByGit();
+    case "zip":
+      return createByZip();
+    default:
+      throw new Error(`Expect parameter opts.way is 'git' or 'zip'`);
+  }
+};
+
+// paths.ts
+var solveValuesFromAddonUrl = (addon) => {
+  const url = new URL(addon);
+  const origin = `${url.protocol}//${url.host}`;
+  const [org, repo, , branch = "", ...subdir] = url.pathname.slice(1).split("/");
+  const ignorePackage = url.searchParams.get("ignorePackage") === "true";
+  return {
+    url: `${origin}/${org}/${repo}`,
+    branch,
+    subdir: subdir.join("/"),
+    protocol: url.protocol,
+    host: url.host,
+    pathname: url.pathname,
+    ignorePackage
+  };
+};
+var solveRepositoryPath = async ({
+  url,
+  branch,
+  subdir
+}) => {
+  const targetId = Buffer.from(`${url}#${branch}#${subdir}`).toString("base64");
+  const target = import_path2.default.join(import_os2.default.homedir(), ".cna", targetId);
+  try {
+    await downloadRepository({
+      git: url,
+      branch,
+      target,
+      targetId
+    });
+  } catch {
+  }
+  return { dir: target, subdir };
+};
+var solveAddonPath = async (addon) => {
+  try {
+    const { url, branch, subdir, protocol, host, pathname, ignorePackage } = solveValuesFromAddonUrl(addon);
+    if (protocol === "file:") {
+      return {
+        dir: import_path2.default.resolve(host, pathname),
+        subdir
+      };
+    }
+    const gitData = await solveRepositoryPath({
+      url,
+      branch,
+      subdir
+    });
+    return { ...gitData, ignorePackage };
+  } catch {
+    return {
+      dir: import_path2.default.resolve(__dirname, "..", "addons", addon),
+      ignorePackage: void 0
+    };
+  }
+};
+var getAddonPackagePath = async (addon, name = "package", ignorePackage = false) => {
+  const {
+    dir,
+    subdir,
+    ignorePackage: addonIgnorePackage
+  } = await solveAddonPath(addon);
+  if (name === "package.json" && (ignorePackage || addonIgnorePackage)) {
+    throw new Error("package.json should be ignored for file addon");
+  }
+  if (subdir) {
+    return import_path2.default.resolve(dir, subdir, name);
+  }
+  return import_path2.default.resolve(dir, name);
+};
+var getAddonTemplateDirPath = async (addonUrl) => {
+  const { dir, subdir = "" } = await solveAddonPath(addonUrl);
+  let templateDirPath = import_path2.default.resolve(dir, subdir);
+  const templateDirPathWithTemplate = import_path2.default.resolve(templateDirPath, "template");
+  return new Promise((resolve, reject) => {
+    import_fs2.default.stat(templateDirPathWithTemplate, (err, stats) => {
+      if (err) {
+        return reject(err);
+      }
+      if (stats.isDirectory()) {
+        templateDirPath = templateDirPathWithTemplate;
+      }
+      resolve(templateDirPath);
+    });
+  });
+};
+
+// package.ts
+var getInstallableSetup = ({
+  dependencies,
+  devDependencies,
+  ...packageJson
+}) => {
+  const getInstallableDeps = (deps = {}) => Object.entries(deps).map(([dep, version]) => `${dep}@${version}`);
+  return {
+    packageJson,
+    dependencies: getInstallableDeps(dependencies),
+    devDependencies: getInstallableDeps(devDependencies)
+  };
+};
+var requireIfExists = (path4) => {
+  if ((0, import_fs3.existsSync)(path4)) {
+    return require(path4);
+  }
+  throw new Error(`file ${path4} not exists`);
+};
+var loadAddonsPackages = async ({
+  addons = [],
+  ignorePackage: globalIgnorePackage = false,
+  ...config
+}) => {
+  const setup = await addons.reduce(
+    async (setupPromise, { url: addon, ignorePackage }) => {
+      let packageJson = await setupPromise;
+      try {
+        const template = requireIfExists(
+          await getAddonPackagePath(addon, "template.json")
+        );
+        packageJson = (0, import_lodash.default)(packageJson, template.package || {});
+      } catch {
+      }
+      try {
+        const addonPackageJson = requireIfExists(
+          await getAddonPackagePath(
+            addon,
+            "package.json",
+            globalIgnorePackage || ignorePackage
+          )
+        );
+        return (0, import_lodash.default)(packageJson, addonPackageJson);
+      } catch {
+      }
+      try {
+        const resolveAddonPackage = requireIfExists(
+          await getAddonPackagePath(addon)
+        );
+        packageJson = resolveAddonPackage(packageJson, config);
+      } catch {
+      }
+      return packageJson;
+    },
+    Promise.resolve({
+      name: config.appName,
+      dependencies: {},
+      devDependencies: {},
+      scripts: {}
+    })
+  );
+  return getInstallableSetup(setup);
+};
+
+// loaders.ts
+var import_underscore = __toESM(require("underscore"));
+var import_fs4 = __toESM(require("fs"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_readdirp = __toESM(require("readdirp"));
+var import_path3 = require("path");
+var SRC_PATH_PATTERN = "[src]/";
+var DEFAULT_SRC_PATH = "src/";
+var getSrcDirPattern = (srcDir) => `${srcDir === "." ? "" : srcDir}/`;
+var copyFile = async (src, dest, verbose = false) => {
+  try {
+    const parentDir = (0, import_path3.dirname)(dest);
+    if (parentDir) {
+      import_fs4.default.mkdirSync(parentDir, { recursive: true });
+    }
+    import_fs4.default.cpSync(src, dest, { force: true, recursive: true });
+    if (verbose) {
+      console.log(import_chalk2.default.green(`Added "${dest}" from "${src}" successfully`));
+    }
+  } catch (err) {
+    console.log(import_chalk2.default.red(`Cannot copy file ${src} to ${dest}`));
+    if (verbose) {
+      console.log(import_chalk2.default.red(err));
+    }
+    throw err;
+  }
+};
+var writeFile = async (path4, content, flag = "w", verbose = false) => {
+  try {
+    const parentDir = (0, import_path3.dirname)(path4);
+    if (parentDir) {
+      import_fs4.default.mkdirSync(parentDir, { recursive: true });
+    }
+    import_fs4.default.writeFileSync(path4, content, { flag });
+    if (verbose) {
+      console.log(import_chalk2.default.green(`Added "${path4}" successfully`));
+    }
+  } catch (err) {
+    console.log(import_chalk2.default.red(`Cannot write file ${path4}`));
+    if (verbose) {
+      console.log(import_chalk2.default.red(err));
+    }
+    throw err;
+  }
+};
+var appendFile = async (src, dest, verbose = false) => {
+  const content = import_fs4.default.readFileSync(src, "utf8");
+  return writeFile(dest, content, "a+", verbose);
+};
+var getModeFromPath = (path4 = "") => {
+  const matchExts = (...exts) => exts.find((ext) => path4.endsWith(ext));
+  if (matchExts(".append")) {
+    return "append";
+  }
+  if (matchExts(".append.template", ".template.append")) {
+    return "appendTemplate";
+  }
+  if (matchExts(".template")) {
+    return "copyTemplate";
+  }
+  return "copy";
+};
+var copyLoader = ({ root, templateDir, verbose, srcDir }) => ({ path: path4 }) => {
+  return copyFile(
+    `${templateDir}/${path4}`,
+    `${root}/${path4}`.replace(SRC_PATH_PATTERN, getSrcDirPattern(srcDir)),
+    verbose
+  );
+};
+var appendLoader = ({ root, templateDir, verbose, srcDir }) => ({ path: path4 }) => {
+  const newPath = path4.replace(/.append$/, "").replace(SRC_PATH_PATTERN, getSrcDirPattern(srcDir));
+  return appendFile(`${templateDir}/${path4}`, `${root}/${newPath}`, verbose);
+};
+var templateLoader = ({
+  root,
+  templateDir,
+  appName,
+  alias,
+  verbose,
+  mode = "",
+  srcDir,
+  runCommand,
+  installCommand
+}) => async ({ path: path4 }) => {
+  const flag = mode.includes("append") ? "a+" : "w";
+  const file = import_fs4.default.readFileSync(`${templateDir}/${path4}`, "utf8");
+  const newFile = import_underscore.default.template(file);
+  const newPath = path4.replace(/.template$/, "").replace(/.append$/, "").replace(SRC_PATH_PATTERN, getSrcDirPattern(srcDir));
+  return writeFile(
+    `${root}/${newPath}`,
+    newFile({
+      project: alias,
+      projectImport: alias,
+      projectImportPath: alias === "" ? "" : `${alias}/`,
+      projectName: appName,
+      srcDir: srcDir || ".",
+      runCommand,
+      installCommand
+    }),
+    flag,
+    verbose
+  );
+};
+var fileLoader = ({
+  root,
+  templateDir,
+  appName,
+  originalDirectory,
+  alias,
+  verbose,
+  srcDir = DEFAULT_SRC_PATH,
+  runCommand,
+  installCommand
+}) => ({ path: path4 }) => {
+  const mode = getModeFromPath(path4);
+  const loaders = {
+    copy: copyLoader,
+    append: appendLoader,
+    copyTemplate: templateLoader,
+    appendTemplate: appendLoader
+  };
+  return loaders[mode]({
+    root,
+    templateDir,
+    appName,
+    originalDirectory,
+    alias,
+    verbose,
+    mode,
+    srcDir,
+    runCommand,
+    installCommand
+  })({
+    path: path4
+  });
+};
+var loadFiles = async ({
+  root,
+  addons = [],
+  appName,
+  originalDirectory,
+  alias,
+  verbose,
+  srcDir = DEFAULT_SRC_PATH,
+  runCommand,
+  installCommand
+}) => {
+  for await (const { url: addonUrl } of addons) {
+    const templateDir = await getAddonTemplateDirPath(addonUrl);
+    if (!import_fs4.default.statSync(templateDir).isDirectory()) {
+      continue;
+    }
+    for await (const entry of (0, import_readdirp.default)(templateDir, {
+      fileFilter: [
+        "!package.js",
+        "!package.json",
+        "!package-lock.json",
+        "!template.json",
+        "!yarn.lock",
+        "!pnpm-lock.yaml"
+      ],
+      directoryFilter: ["!package"]
+    })) {
+      try {
+        await fileLoader({
+          root,
+          templateDir,
+          appName,
+          originalDirectory,
+          alias,
+          verbose,
+          srcDir,
+          runCommand,
+          installCommand
+        })(entry);
+      } catch (err) {
+        if (verbose) {
+          console.log(err);
+        }
+        throw err;
+      }
+    }
+  }
+};
+
+// installer.ts
+var install = (root, useYarn = false, dependencies = [], verbose = false, isOnline = true, isDevDependencies = false) => {
+  return new Promise((resolve, reject) => {
+    let command;
+    let args;
+    if (useYarn) {
+      command = "yarnpkg";
+      args = ["add"];
+      if (!isOnline) {
+        args.push("--offline");
+      }
+      if (isDevDependencies) {
+        args.push("--dev");
+      }
+      args.push(...dependencies);
+      args.push("--cwd");
+      args.push(root);
+      if (!isOnline) {
+        console.log(import_chalk3.default.yellow("You appear to be offline."));
+        console.log(import_chalk3.default.yellow("Falling back to the local Yarn cache."));
+        console.log();
+      }
+    } else {
+      command = "npm";
+      args = ["install", "--loglevel", "error"];
+      if (isDevDependencies) {
+        args.push("--save-dev");
+      } else {
+        args.push("--save");
+      }
+      args.push(...dependencies);
+    }
+    if (verbose) {
+      args.push("--verbose");
+    }
+    const child = (0, import_cross_spawn2.default)(command, args, { stdio: "inherit", cwd: root });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`${command} ${args.join(" ")}`));
+        return;
+      }
+      resolve();
+    });
+  });
+};
+var run = async ({
+  root,
+  appName,
+  originalDirectory,
+  verbose = false,
+  useYarn = false,
+  addons = [],
+  dependencies = [],
+  devDependencies = [],
+  alias = "",
+  installDependencies = true,
+  srcDir = "",
+  runCommand = "",
+  installCommand = ""
+}) => {
+  let isOnline = true;
+  if (useYarn) {
+    isOnline = await checkIfOnline(useYarn);
+  }
+  if (import_underscore2.default.isEmpty(addons)) {
+    console.log();
+    console.log(import_chalk3.default.yellow("No addons specified to bootstrap application."));
+    console.log();
+    process.exit(0);
+  }
+  await loadFiles({
+    root,
+    addons,
+    appName,
+    originalDirectory,
+    alias,
+    verbose,
+    srcDir,
+    runCommand,
+    installCommand
+  });
+  if (installDependencies) {
+    console.log(
+      import_chalk3.default.green("Installing packages. This might take a couple of minutes.")
+    );
+    console.log(import_chalk3.default.green("Installing dependencies..."));
+    console.log();
+    await install(root, useYarn, dependencies, verbose, isOnline, false);
+    if (devDependencies.length > 0) {
+      console.log();
+      console.log(import_chalk3.default.green("Installing devDependencies..."));
+      console.log();
+      await install(root, useYarn, devDependencies, verbose, isOnline, true);
+    }
+  } else {
+    console.log(import_chalk3.default.yellow("Skip package installation."));
+    console.log(import_chalk3.default.yellow("Run npm install/yarn in your project."));
+    const packageJson = JSON.parse(
+      import_fs5.default.readFileSync(`${root}/package.json`, "utf8")
+    );
+    packageJson.dependencies = dependencies.reduce((dep, elem) => {
+      const nextDep = dep;
+      if (/.+@(\^|~)?[0-9a-zA-Z-.]+$/.test(elem)) {
+        const [name, version] = elem.split("@");
+        nextDep[name] = `${version}`;
+      } else {
+        nextDep[elem] = "*";
+      }
+      return nextDep;
+    }, {});
+    packageJson.devDependencies = devDependencies.reduce((dep, elem) => {
+      const nextDep = dep;
+      if (/.+@(\^|~)?[0-9a-zA-Z-.]+$/.test(elem)) {
+        const [name, version] = elem.split("@");
+        nextDep[name] = `${version}`;
+      } else {
+        nextDep[elem] = "*";
+      }
+      return nextDep;
+    }, {});
+    import_fs5.default.writeFileSync(
+      import_path4.default.join(root, "package.json"),
+      JSON.stringify(packageJson, null, 2) + import_os3.default.EOL
+    );
+  }
+  (0, import_cross_spawn2.default)("git", ["init"], {
+    cwd: root
+  });
+  if (installDependencies && isOnline) {
+    const packageJson = JSON.parse(
+      import_fs5.default.readFileSync(`${root}/package.json`, "utf8")
+    );
+    if (packageJson.scripts && packageJson.scripts["lint:fix"]) {
+      (0, import_cross_spawn2.default)(runCommand, ["lint:fix"], { stdio: "inherit", cwd: root });
+    }
+  }
+};
+var createApp = async ({
+  name,
+  verbose = false,
+  useNpm = false,
+  addons = [],
+  alias = "",
+  installDependencies = true,
+  ignorePackage = false,
+  srcDir = ""
+}) => {
+  const root = import_path4.default.resolve(name);
+  const appName = import_path4.default.basename(root);
+  import_fs5.default.mkdirSync(name, {
+    recursive: true
+  });
+  console.log(`Creating a new Node app in ${import_chalk3.default.green(root)}.`);
+  console.log();
+  const useYarn = useNpm ? false : shouldUseYarn();
+  const command = useYarn ? "yarn" : "npm run";
+  const { packageJson, dependencies, devDependencies } = await loadAddonsPackages({
+    addons,
+    appName,
+    command,
+    ignorePackage,
+    srcDir
+  });
+  import_fs5.default.writeFileSync(
+    import_path4.default.join(root, "package.json"),
+    JSON.stringify(packageJson, null, 2) + import_os3.default.EOL
+  );
+  const originalDirectory = process.cwd();
+  process.chdir(root);
+  if (!useYarn && !checkThatNpmCanReadCwd()) {
+    process.exit(1);
+  }
+  if (!import_semver2.default.satisfies(process.version, ">=16.0.0")) {
+    console.log(
+      import_chalk3.default.yellow(
+        `You are using Node ${process.version} so the project will be bootstrapped with an old unsupported version of tools.
+
+Please update to Node 16 or higher for a better, fully supported experience.
+`
+      )
+    );
+  }
+  if (!useYarn) {
+    const npmInfo = checkNpmVersion();
+    if (!npmInfo.hasMinNpm) {
+      if (npmInfo.npmVersion) {
+        console.log(
+          import_chalk3.default.yellow(
+            `You are using npm ${npmInfo.npmVersion} so the project will be bootstrapped with an old unsupported version of tools.
+
+Please update to npm 3 or higher for a better, fully supported experience.
+`
+          )
+        );
+      }
+    }
+  }
+  if (useYarn) {
+    let yarnUsesDefaultRegistry = true;
+    try {
+      yarnUsesDefaultRegistry = (0, import_child_process3.execSync)("yarnpkg config get registry").toString().trim() === "https://registry.yarnpkg.com";
+    } catch (e) {
+    }
+    if (false) {
+      import_fs5.default.cpSync(
+        null,
+        import_path4.default.join(root, "yarn.lock"),
+        { force: true }
+      );
+    }
+  }
+  return run({
+    root,
+    appName,
+    originalDirectory,
+    verbose,
+    useYarn,
+    addons,
+    dependencies,
+    devDependencies,
+    alias,
+    installDependencies,
+    srcDir,
+    runCommand: command,
+    installCommand: useYarn ? "yarn" : "npm install"
+  });
+};
+
+// index.ts
+var printEnvInfo = async () => {
+  console.log(import_chalk4.default.bold("\nEnvironment Info:"));
+  const info = await import_envinfo.default.run(
+    {
+      System: ["OS", "CPU"],
+      Binaries: ["Node", "npm", "Yarn"],
+      Browsers: ["Chrome", "Edge", "Internet Explorer", "Firefox", "Safari"]
+    },
+    {
+      duplicates: true,
+      showNotFound: true
+    }
+  );
+  console.log(info);
+  process.exit(0);
+};
+var createNodeApp = async (programName, options, transformOptions) => {
+  if (options.info) {
+    await printEnvInfo();
+  }
+  if (typeof options.projectName === "undefined") {
+    console.error("Please specify the project directory:");
+    console.log(
+      `  ${import_chalk4.default.cyan(programName)} ${import_chalk4.default.green("[project-directory]")}`
+    );
+    console.log();
+    console.log("For example:");
+    console.log(`  ${import_chalk4.default.cyan(programName)} ${import_chalk4.default.green("my-app")}`);
+    console.log();
+    console.log(
+      `Run ${import_chalk4.default.cyan(`${programName} --help`)} to see all options.`
+    );
+    process.exit(1);
+  }
+  const appOptions = await transformOptions(options);
+  await createApp({
+    ...appOptions,
+    name: appOptions.projectName,
+    installDependencies: !options.nodeps
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNodeApp,
+  printEnvInfo
+});