@create-node-app/core 0.0.0

package/dist/index.mjs

@@ -0,0 +1,839 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// index.ts
+import chalk4 from "chalk";
+import envinfo from "envinfo";
+
+// installer.ts
+import _2 from "underscore";
+import path3 from "path";
+import fs4 from "fs";
+import chalk3 from "chalk";
+import os3 from "os";
+import semver2 from "semver";
+import spawn2 from "cross-spawn";
+import { execSync as execSync2 } from "child_process";
+
+// helpers.ts
+import { execSync } from "child_process";
+import spawn from "cross-spawn";
+import chalk from "chalk";
+import semver from "semver";
+import dns from "dns";
+import { URL as URL2 } from "url";
+var shouldUseYarn = () => {
+  try {
+    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 = spawn.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(
+    chalk.red(
+      `Could not start an npm process in the right directory.
+
+The current directory is: ${chalk.bold(cwd)}
+However, a newly started npm process runs in: ${chalk.bold(
+        npmCWD
+      )}
+
+This is probably caused by a misconfigured system terminal shell.`
+    )
+  );
+  if (process.platform === "win32") {
+    console.error(
+      chalk.red(`On Windows, this can usually be fixed by running:
+
+`) + `  ${chalk.cyan(
+        "reg"
+      )} delete "HKCU\\Software\\Microsoft\\Command Processor" /v AutoRun /f
+  ${chalk.cyan(
+        "reg"
+      )} delete "HKLM\\Software\\Microsoft\\Command Processor" /v AutoRun /f
+
+` + chalk.red(`Try to run the above two lines in the terminal.
+`) + chalk.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 = execSync("npm --version").toString().trim();
+    hasMinNpm = semver.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 = 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) => {
+    dns.lookup("registry.yarnpkg.com", (err) => {
+      let proxy;
+      if (err != null && (proxy = getProxy())) {
+        dns.lookup(new URL2(proxy).hostname, (proxyErr) => {
+          resolve(!proxyErr);
+        });
+      } else {
+        resolve(!err);
+      }
+    });
+  });
+};
+
+// package.ts
+import { existsSync } from "fs";
+import merge from "lodash.merge";
+
+// paths.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+
+// git.ts
+import os from "os";
+import childProcess from "child_process";
+import path from "path";
+import { promisify } from "util";
+import fs from "fs";
+import download from "download";
+import debug from "debug";
+var log = debug("cna:git");
+var exec = promisify(childProcess.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 = path.isAbsolute(target) ? target : path.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 || path.join(os.homedir(), ".cache", "cna", id);
+  cacheDir = path.isAbsolute(cacheDir) ? cacheDir : path.resolve(cacheDir);
+  log("cache folder: %s", cacheDir);
+  log("git url: %s", gitUrl);
+  log("zip url: %s", zipUrl);
+  const cached = fs.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) {
+      fs.cpSync(cacheDir, absoluteTarget, {
+        force: true,
+        filter: filterGit,
+        recursive: true
+      });
+      return;
+    }
+    await pull(cacheDir);
+    setTimeout(() => {
+      fs.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 download(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 = path2.join(os2.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: path2.resolve(host, pathname),
+        subdir
+      };
+    }
+    const gitData = await solveRepositoryPath({
+      url,
+      branch,
+      subdir
+    });
+    return { ...gitData, ignorePackage };
+  } catch {
+    return {
+      dir: path2.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 path2.resolve(dir, subdir, name);
+  }
+  return path2.resolve(dir, name);
+};
+var getAddonTemplateDirPath = async (addonUrl) => {
+  const { dir, subdir = "" } = await solveAddonPath(addonUrl);
+  let templateDirPath = path2.resolve(dir, subdir);
+  const templateDirPathWithTemplate = path2.resolve(templateDirPath, "template");
+  return new Promise((resolve, reject) => {
+    fs2.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 (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 = merge(packageJson, template.package || {});
+      } catch {
+      }
+      try {
+        const addonPackageJson = requireIfExists(
+          await getAddonPackagePath(
+            addon,
+            "package.json",
+            globalIgnorePackage || ignorePackage
+          )
+        );
+        return merge(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
+import _ from "underscore";
+import fs3 from "fs";
+import chalk2 from "chalk";
+import readdirp from "readdirp";
+import { dirname } from "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 = dirname(dest);
+    if (parentDir) {
+      fs3.mkdirSync(parentDir, { recursive: true });
+    }
+    fs3.cpSync(src, dest, { force: true, recursive: true });
+    if (verbose) {
+      console.log(chalk2.green(`Added "${dest}" from "${src}" successfully`));
+    }
+  } catch (err) {
+    console.log(chalk2.red(`Cannot copy file ${src} to ${dest}`));
+    if (verbose) {
+      console.log(chalk2.red(err));
+    }
+    throw err;
+  }
+};
+var writeFile = async (path4, content, flag = "w", verbose = false) => {
+  try {
+    const parentDir = dirname(path4);
+    if (parentDir) {
+      fs3.mkdirSync(parentDir, { recursive: true });
+    }
+    fs3.writeFileSync(path4, content, { flag });
+    if (verbose) {
+      console.log(chalk2.green(`Added "${path4}" successfully`));
+    }
+  } catch (err) {
+    console.log(chalk2.red(`Cannot write file ${path4}`));
+    if (verbose) {
+      console.log(chalk2.red(err));
+    }
+    throw err;
+  }
+};
+var appendFile = async (src, dest, verbose = false) => {
+  const content = fs3.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 = fs3.readFileSync(`${templateDir}/${path4}`, "utf8");
+  const newFile = _.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 (!fs3.statSync(templateDir).isDirectory()) {
+      continue;
+    }
+    for await (const entry of readdirp(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(chalk3.yellow("You appear to be offline."));
+        console.log(chalk3.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 = spawn2(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 (_2.isEmpty(addons)) {
+    console.log();
+    console.log(chalk3.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(
+      chalk3.green("Installing packages. This might take a couple of minutes.")
+    );
+    console.log(chalk3.green("Installing dependencies..."));
+    console.log();
+    await install(root, useYarn, dependencies, verbose, isOnline, false);
+    if (devDependencies.length > 0) {
+      console.log();
+      console.log(chalk3.green("Installing devDependencies..."));
+      console.log();
+      await install(root, useYarn, devDependencies, verbose, isOnline, true);
+    }
+  } else {
+    console.log(chalk3.yellow("Skip package installation."));
+    console.log(chalk3.yellow("Run npm install/yarn in your project."));
+    const packageJson = JSON.parse(
+      fs4.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;
+    }, {});
+    fs4.writeFileSync(
+      path3.join(root, "package.json"),
+      JSON.stringify(packageJson, null, 2) + os3.EOL
+    );
+  }
+  spawn2("git", ["init"], {
+    cwd: root
+  });
+  if (installDependencies && isOnline) {
+    const packageJson = JSON.parse(
+      fs4.readFileSync(`${root}/package.json`, "utf8")
+    );
+    if (packageJson.scripts && packageJson.scripts["lint:fix"]) {
+      spawn2(runCommand, ["lint:fix"], { stdio: "inherit", cwd: root });
+    }
+  }
+};
+var createApp = async ({
+  name,
+  verbose = false,
+  useNpm = false,
+  addons = [],
+  alias = "",
+  installDependencies = true,
+  ignorePackage = false,
+  srcDir = ""
+}) => {
+  const root = path3.resolve(name);
+  const appName = path3.basename(root);
+  fs4.mkdirSync(name, {
+    recursive: true
+  });
+  console.log(`Creating a new Node app in ${chalk3.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
+  });
+  fs4.writeFileSync(
+    path3.join(root, "package.json"),
+    JSON.stringify(packageJson, null, 2) + os3.EOL
+  );
+  const originalDirectory = process.cwd();
+  process.chdir(root);
+  if (!useYarn && !checkThatNpmCanReadCwd()) {
+    process.exit(1);
+  }
+  if (!semver2.satisfies(process.version, ">=16.0.0")) {
+    console.log(
+      chalk3.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(
+          chalk3.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 = execSync2("yarnpkg config get registry").toString().trim() === "https://registry.yarnpkg.com";
+    } catch (e) {
+    }
+    if (false) {
+      fs4.cpSync(
+        __require.resolve("./yarn.lock.cached"),
+        path3.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(chalk4.bold("\nEnvironment Info:"));
+  const info = await envinfo.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(
+      `  ${chalk4.cyan(programName)} ${chalk4.green("[project-directory]")}`
+    );
+    console.log();
+    console.log("For example:");
+    console.log(`  ${chalk4.cyan(programName)} ${chalk4.green("my-app")}`);
+    console.log();
+    console.log(
+      `Run ${chalk4.cyan(`${programName} --help`)} to see all options.`
+    );
+    process.exit(1);
+  }
+  const appOptions = await transformOptions(options);
+  await createApp({
+    ...appOptions,
+    name: appOptions.projectName,
+    installDependencies: !options.nodeps
+  });
+};
+export {
+  createNodeApp,
+  printEnvInfo
+};