vercel · m19c · Dec 14, 2021 · jaredpalmer · Dec 14, 2021 · m19c
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo "test"
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo "test"
@@ -67,16 +67,21 @@ describe("create-turbo cli", () => {
           break;
 
         case 3:
-          // Which package manager do you want to use?
-          // easy to change deployment targets.
-          expect(getPromptChoices(prompt)).toEqual(["Yarn", "NPM"]);
+          const chocies = getPromptChoices(prompt);
+
+          // yarn is optional. however, npm should be present on almost
+          // every system.
+          expect(chocies).toContain("NPM");
+
+          // just hit enter to pick the first result from the list.
           cli.stdin.write(keys.enter);
           break;
 
         case 4:
-          expect(prompt).toEqual(
-            "? Do you want me to run `yarn install`? (Y/n)"
+          expect(prompt).toMatch(
+            /\? Do you want me to run \`(yarn|npm) install\`\? \(Y\/n\)/
           );
+
           cli.stdin.write("n");
 
           // At this point the CLI will create directories and all that fun stuff

@@ -0,0 +1,29 @@
+import path from "path";
+
+import { hasExecutable } from "../src/hasExecutable";
+
+const baseDirectory = path.join(__dirname, "__data__");
+
+describe("hasExecutable", () => {
+  test("works with process.env.PATH and process.env.PATHEXT", async () => {
+    expect(await hasExecutable("node")).toBeTruthy();
+  });
+
+  test("returns true, if the executable is present", async () => {
+    expect(
+      await hasExecutable("b", [path.resolve(baseDirectory, "a")])
+    ).toBeTruthy();
+  });
+
+  test("returns false, if the executable is not present", async () => {
+    expect(
+      await hasExecutable("c", [path.resolve(baseDirectory, "c")])
+    ).toBeFalsy();
+  });
+
+  test("works with extensions", async () => {
+    expect(
+      await hasExecutable("e", [path.resolve(baseDirectory, "d")], [".command"])
+    ).toBeTruthy();
+  });
+});
@@ -0,0 +1,42 @@
+import path from "path";
+import fs from "fs/promises";
+
+const environmentPaths = (process.env.PATH || "")
+  .replace(/["]+/g, "")
+  .split(path.delimiter)
+  .filter(Boolean);
+
+const environmentExtensions = (process.env.PATHEXT || "").split(";");
+
+/**
+ * Determines whether or not the given executable is present on the system.
+ *
+ * Inspired by https://github.com/springernature/hasbin/blob/master/lib/hasbin.js#L55
+ *
+ * @param name
+ */
+export async function hasExecutable(
+  executable: string,
+  paths = environmentPaths,
+  extensions = environmentExtensions
+) {
+  try {
+    return await Promise.any(
+      paths
+        .flatMap((d) => extensions.map((ext) => path.join(d, executable + ext)))
+        .map(isFilePresent)
+    );
+  } catch (err) {
+    return false;
+  }
+}
+
+async function isFilePresent(path: string) {
+  const stats = await fs.stat(path);
+
+  if (stats.isFile()) {
+    return true;
+  }
+
+  throw new Error(`${path} is not a file`);
+}
@@ -12,6 +12,7 @@ import chalk from "chalk";
 import cliPkgJson from "../package.json";
 import { shouldUseYarn } from "./shouldUseYarn";
 import { tryGitInit } from "./git";
+import { hasExecutable } from "./hasExecutable";
 
 const turboGradient = gradient("#0099F7", "#F11712");
 const help = `
@@ -88,7 +89,11 @@ async function run() {
       type: "list",
       message: "Which package manager do you want to use?",
       choices: [
-        { name: "Yarn", value: "yarn" },
+        {
+          name: "Yarn",
+          value: "yarn",
+          disabled: !(await hasExecutable("yarn")),
+        },
         { name: "NPM", value: "npm" },
         // { name: "PNPM", value: "pnpm" },
       ],
@@ -246,7 +251,7 @@ async function notifyUpdate(): Promise<void> {
   try {
     const res = await update;
     if (res?.latest) {
-      const isYarn = shouldUseYarn();
+      const isYarn = await shouldUseYarn();
 
       console.log();
       console.log(

@@ -1,14 +1,10 @@
-import { execSync } from "child_process";
+import { hasExecutable } from "./hasExecutable";
 
-export function shouldUseYarn(): boolean {
-  try {
-    const userAgent = process.env.npm_config_user_agent;
-    if (userAgent) {
-      return Boolean(userAgent && userAgent.startsWith("yarn"));
-    }
-    execSync("yarnpkg --version", { stdio: "ignore" });
-    return true;
-  } catch (e) {
-    return false;
+export async function shouldUseYarn() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    return Boolean(userAgent && userAgent.startsWith("yarn"));
   }
+
+  return hasExecutable("yarn");
 }