create-bcp-app 0.1.11 → 0.1.13

package/bin/create-bcp-app.mjs

@@ -2,9 +2,8 @@
 
 import path from "node:path";
 import {
-    createInterface,
-} from "node:readline/promises";
-
+    emitKeypressEvents,
+} from "node:readline";
 import {
     stdin as input,
     stdout as output,
@@ -20,402 +19,253 @@ import {
     normalizeDatabase,
 } from "../src/project-options.mjs";
 
-const args =
-    process.argv.slice(2);
+const ANSI = {
+    reset: "\u001B[0m",
+    selected: "\u001B[46m\u001B[30m\u001B[1m",
+    muted: "\u001B[2m",
+};
 
-if (
-    args.includes("--help") ||
-    args.includes("-h")
-) {
-    printHelp();
-    process.exit(0);
-}
+await main();
 
-let projectDirectory =
-    null;
-let install =
-    true;
-let bcpPackage =
-    undefined;
-let tailwind =
-    undefined;
-let database =
-    undefined;
-let auth =
-    undefined;
-let acceptDefaults =
-    false;
-
-for (
-    let index = 0;
-    index < args.length;
-    index++
-) {
-    const value =
-        args[index];
+async function main() {
+    const args = process.argv.slice(2);
 
     if (
-        value === "--no-install"
+        args.includes("--help") ||
+        args.includes("-h")
     ) {
-        install =
-            false;
-        continue;
+        printHelp();
+        return;
     }
 
-    if (
-        value === "--yes" ||
-        value === "-y"
-    ) {
-        acceptDefaults =
-            true;
-        continue;
+    let parsed;
+
+    try {
+        parsed = parseArguments(args);
+    } catch (error) {
+        reportError(error);
+        return;
     }
 
-    if (
-        value === "--tailwind"
-    ) {
-        tailwind =
-            true;
-        continue;
+    if (!parsed.projectDirectory) {
+        printHelp();
+        process.exitCode = 1;
+        return;
     }
 
-    if (
-        value === "--no-tailwind"
-    ) {
-        tailwind =
-            false;
-        continue;
+    try {
+        const resolved = await resolveOptions(parsed);
+
+        console.log("");
+        console.log(
+            parsed.install
+                ? `Creating BCP app and installing dependencies in ${path.resolve(parsed.projectDirectory)}...`
+                : `Creating BCP app in ${path.resolve(parsed.projectDirectory)}...`
+        );
+        console.log("");
+
+        const result = await createBcpApp({
+            projectDirectory: parsed.projectDirectory,
+            install: parsed.install,
+            bcpPackage: parsed.bcpPackage,
+            tailwind: resolved.tailwind,
+            database: resolved.database,
+            auth: resolved.auth,
+            packageManager: "npm",
+        });
+
+        printSuccess(result, parsed.install);
+    } catch (error) {
+        reportError(error);
     }
+}
 
-    if (
-        value === "--database"
+function parseArguments(args) {
+    let projectDirectory = null;
+    let install = true;
+    let bcpPackage = undefined;
+    let tailwind = undefined;
+    let database = undefined;
+    let auth = undefined;
+    let acceptDefaults = false;
+
+    for (
+        let index = 0;
+        index < args.length;
+        index++
     ) {
-        const nextValue =
-            args[
-                index + 1
-            ];
-
-        if (!nextValue) {
-            fail(
-                "--database requires a value."
-            );
+        const value = args[index];
+
+        if (value === "--no-install") {
+            install = false;
+            continue;
         }
 
-        database =
-            normalizeDatabase(
-                nextValue
-            );
-        index++;
-        continue;
-    }
+        if (
+            value === "--yes" ||
+            value === "-y"
+        ) {
+            acceptDefaults = true;
+            continue;
+        }
 
-    if (
-        value === "--auth"
-    ) {
-        const nextValue =
-            args[
-                index + 1
-            ];
-
-        if (!nextValue) {
-            fail(
-                "--auth requires a value."
-            );
+        if (value === "--tailwind") {
+            tailwind = true;
+            continue;
         }
 
-        auth =
-            normalizeAuth(
-                nextValue
-            );
-        index++;
-        continue;
-    }
+        if (value === "--no-tailwind") {
+            tailwind = false;
+            continue;
+        }
 
-    if (
-        value === "--bcp"
-    ) {
-        const nextValue =
-            args[
-                index + 1
-            ];
-
-        if (!nextValue) {
-            fail(
-                "--bcp requires a package specifier."
-            );
+        if (value === "--database") {
+            const nextValue = args[index + 1];
+
+            if (!nextValue) {
+                throw new Error(
+                    "--database requires a value."
+                );
+            }
+
+            database = normalizeDatabase(nextValue);
+            index++;
+            continue;
         }
 
-        bcpPackage =
-            nextValue;
-        index++;
-        continue;
-    }
+        if (value === "--auth") {
+            const nextValue = args[index + 1];
 
-    if (
-        value.startsWith("-")
-    ) {
-        fail(
-            `Unknown option: ${value}`
-        );
-    }
+            if (!nextValue) {
+                throw new Error(
+                    "--auth requires a value."
+                );
+            }
 
-    if (
-        projectDirectory !==
-        null
-    ) {
-        fail(
-            "Only one project directory may be provided."
-        );
-    }
+            auth = normalizeAuth(nextValue);
+            index++;
+            continue;
+        }
 
-    projectDirectory =
-        value;
-}
+        if (value === "--bcp") {
+            const nextValue = args[index + 1];
 
-if (!projectDirectory) {
-    printHelp();
-    process.exitCode =
-        1;
-} else {
-    try {
-        const selected =
-            await resolveInteractiveOptions({
-                tailwind,
-                database,
-                auth,
-                acceptDefaults,
-            });
-
-        const result =
-            await createBcpApp({
-                projectDirectory,
-                install,
-                bcpPackage,
-                tailwind:
-                    selected.tailwind,
-                database:
-                    selected.database,
-                auth:
-                    selected.auth,
-                packageManager:
-                    "npm",
-            });
-
-        const relative =
-            path.relative(
-                process.cwd(),
-                result.targetDirectory
-            ) || ".";
+            if (!nextValue) {
+                throw new Error(
+                    "--bcp requires a package specifier."
+                );
+            }
 
-        console.log("");
-        console.log(
-            `Created BCP app: ${result.projectName}`
-        );
-        console.log(
-            `Location: ${result.targetDirectory}`
-        );
-        console.log(
-            `Tailwind CSS: ${result.tailwind ? "Yes" : "No"}`
-        );
-        console.log(
-            `Database: ${formatDatabaseName(result.database)}`
-        );
-        console.log(
-            `Authentication: ${formatAuthName(result.auth)}`
-        );
-        console.log("");
-        console.log(
-            "Next steps:"
-        );
-        console.log(
-            `  cd ${quoteIfNeeded(relative)}`
-        );
+            bcpPackage = nextValue;
+            index++;
+            continue;
+        }
 
-        if (!install) {
-            console.log(
-                "  npm install"
+        if (value.startsWith("-")) {
+            throw new Error(
+                `Unknown option: ${value}`
             );
         }
 
-        console.log(
-            "  npm run dev"
-        );
-        console.log("");
-    } catch (error) {
-        fail(
-            error instanceof Error
-                ? error.message
-                : String(error)
-        );
+        if (projectDirectory !== null) {
+            throw new Error(
+                "Only one project directory may be provided."
+            );
+        }
+
+        projectDirectory = value;
     }
+
+    return {
+        projectDirectory,
+        install,
+        bcpPackage,
+        tailwind,
+        database,
+        auth,
+        acceptDefaults,
+    };
 }
 
-async function resolveInteractiveOptions({
+async function resolveOptions({
     tailwind: selectedTailwind,
     database: selectedDatabase,
     auth: selectedAuth,
-    acceptDefaults: useDefaults,
+    acceptDefaults,
 }) {
-    let resolvedTailwind =
-        selectedTailwind;
-    let resolvedDatabase =
-        selectedDatabase;
-    let resolvedAuth =
-        selectedAuth;
-
-    const interactive =
-        Boolean(
-            input.isTTY &&
-            output.isTTY
-        );
+    let tailwind = selectedTailwind;
+    let database = selectedDatabase;
+    let auth = selectedAuth;
 
-    if (useDefaults) {
+    if (acceptDefaults) {
         return {
-            tailwind:
-                resolvedTailwind ??
-                true,
-            database:
-                normalizeDatabase(
-                    resolvedDatabase ??
-                    "none"
-                ),
-            auth:
-                normalizeAuth(
-                    resolvedAuth ??
-                    "none"
-                ),
+            tailwind: tailwind ?? true,
+            database: normalizeDatabase(
+                database ?? "none"
+            ),
+            auth: normalizeAuth(
+                auth ?? "none"
+            ),
         };
     }
 
+    const interactive = Boolean(
+        input.isTTY &&
+        output.isTTY
+    );
+
     if (!interactive) {
         return {
-            tailwind:
-                resolvedTailwind ??
-                false,
-            database:
-                normalizeDatabase(
-                    resolvedDatabase ??
-                    "none"
-                ),
-            auth:
-                normalizeAuth(
-                    resolvedAuth ??
-                    "none"
-                ),
+            tailwind: tailwind ?? false,
+            database: normalizeDatabase(
+                database ?? "none"
+            ),
+            auth: normalizeAuth(
+                auth ?? "none"
+            ),
         };
     }
 
-    const prompt =
-        createInterface({
-            input,
-            output,
-        });
+    console.log("");
+    console.log("Configure your BCP app");
+    console.log("");
 
-    try {
-        console.log("");
-        console.log(
-            "Configure your BCP app"
-        );
-        console.log("");
-
-        if (
-            resolvedTailwind ===
-            undefined
-        ) {
-            resolvedTailwind =
-                await askYesNo(
-                    prompt,
-                    "Use Tailwind CSS?",
-                    true
-                );
-        }
+    if (tailwind === undefined) {
+        tailwind = await askTailwind();
+    }
 
-        if (
-            resolvedDatabase ===
-            undefined
-        ) {
-            resolvedDatabase =
-                await askDatabase(
-                    prompt
-                );
-        }
+    if (database === undefined) {
+        database = await askDatabase();
+    }
 
-        if (
-            resolvedAuth ===
-            undefined
-        ) {
-            resolvedAuth =
-                await askAuth(
-                    prompt
-                );
-        }
-    } finally {
-        prompt.close();
+    if (auth === undefined) {
+        auth = await askAuth();
     }
 
     return {
-        tailwind:
-            Boolean(
-                resolvedTailwind
-            ),
-        database:
-            normalizeDatabase(
-                resolvedDatabase
-            ),
-        auth:
-            normalizeAuth(
-                resolvedAuth
-            ),
+        tailwind: Boolean(tailwind),
+        database: normalizeDatabase(database),
+        auth: normalizeAuth(auth),
     };
 }
 
-async function askYesNo(
-    prompt,
-    label,
-    defaultValue
-) {
-    const suffix =
-        defaultValue
-            ? " (Y/n) "
-            : " (y/N) ";
-
-    while (true) {
-        const answer =
-            (
-                await prompt.question(
-                    `${label}${suffix}`
-                )
-            )
-                .trim()
-                .toLowerCase();
-
-        if (!answer) {
-            return defaultValue;
-        }
-
-        if (
-            answer === "y" ||
-            answer === "yes"
-        ) {
-            return true;
-        }
-
-        if (
-            answer === "n" ||
-            answer === "no"
-        ) {
-            return false;
-        }
-
-        console.log(
-            "Please answer yes or no."
-        );
-    }
+function askTailwind() {
+    return askTerminalSelect(
+        "Use Tailwind CSS?",
+        [
+            {
+                value: true,
+                label: "Yes",
+            },
+            {
+                value: false,
+                label: "No",
+            },
+        ]
+    );
 }
 
-async function askDatabase(
-    prompt
-) {
+function askDatabase() {
     const labels = {
         none: "None",
         mysql: "MySQL",
@@ -424,142 +274,233 @@ async function askDatabase(
         mongodb: "MongoDB",
     };
 
-    console.log(
-        "Select a database:"
-    );
-
-    DATABASE_CHOICES.forEach(
-        (
-            value,
-            index
-        ) => {
-            console.log(
-                `  ${index + 1}) ${labels[value]}`
-            );
-        }
+    return askTerminalSelect(
+        "Select a database:",
+        DATABASE_CHOICES.map(
+            (value) => ({
+                value,
+                label: labels[value],
+            })
+        )
     );
-
-    while (true) {
-        const answer =
-            (
-                await prompt.question(
-                    "Database (1): "
-                )
-            ).trim();
-
-        if (!answer) {
-            return "none";
-        }
-
-        const index =
-            Number(
-                answer
-            ) - 1;
-
-        if (
-            Number.isInteger(
-                index
-            ) &&
-            index >= 0 &&
-            index <
-                DATABASE_CHOICES.length
-        ) {
-            return DATABASE_CHOICES[
-                index
-            ];
-        }
-
-        const normalized =
-            answer.toLowerCase();
-
-        if (
-            DATABASE_CHOICES.includes(
-                normalized
-            )
-        ) {
-            return normalized;
-        }
-
-        console.log(
-            "Choose a number from the list or enter a database name."
-        );
-    }
 }
 
-async function askAuth(
-    prompt
-) {
+function askAuth() {
     const labels = {
         none: "None",
-        "jwt-cookie":
-            "JWT Cookie",
+        "jwt-cookie": "JWT Cookie",
     };
 
-    console.log(
-        "Select authentication:"
+    return askTerminalSelect(
+        "Select authentication:",
+        AUTH_CHOICES.map(
+            (value) => ({
+                value,
+                label: labels[value],
+            })
+        )
     );
+}
+
+function askTerminalSelect(
+    label,
+    choices
+) {
+    if (
+        !Array.isArray(choices) ||
+        choices.length === 0
+    ) {
+        return Promise.reject(
+            new Error(
+                "Interactive selection requires at least one choice."
+            )
+        );
+    }
+
+    if (
+        typeof input.setRawMode !== "function"
+    ) {
+        return Promise.resolve(
+            choices[0].value
+        );
+    }
 
-    AUTH_CHOICES.forEach(
+    return new Promise(
         (
-            value,
-            index
+            resolve,
+            reject
         ) => {
+            let selectedIndex = 0;
+            const previousRawMode =
+                input.isRaw === true;
+
+            const render = (
+                redraw = false
+            ) => {
+                if (redraw) {
+                    output.write(
+                        `\u001B[${choices.length}A`
+                    );
+                }
+
+                for (
+                    let index = 0;
+                    index < choices.length;
+                    index++
+                ) {
+                    const choice = choices[index];
+                    const selected =
+                        index === selectedIndex;
+
+                    output.write(
+                        "\u001B[2K\r"
+                    );
+
+                    if (selected) {
+                        output.write(
+                            `${ANSI.selected} > ${choice.label} ${ANSI.reset}\n`
+                        );
+                    } else {
+                        output.write(
+                            `   ${choice.label}\n`
+                        );
+                    }
+                }
+            };
+
+            const cleanup = () => {
+                input.removeListener(
+                    "keypress",
+                    onKeypress
+                );
+                input.setRawMode(
+                    previousRawMode
+                );
+
+                if (!previousRawMode) {
+                    input.pause();
+                }
+            };
+
+            const onKeypress = (
+                _character,
+                key = {}
+            ) => {
+                if (
+                    key.ctrl &&
+                    key.name === "c"
+                ) {
+                    cleanup();
+                    output.write("\n");
+                    reject(
+                        new Error(
+                            "Setup cancelled."
+                        )
+                    );
+                    return;
+                }
+
+                if (
+                    key.name === "escape"
+                ) {
+                    cleanup();
+                    output.write("\n");
+                    reject(
+                        new Error(
+                            "Setup cancelled."
+                        )
+                    );
+                    return;
+                }
+
+                if (key.name === "up") {
+                    selectedIndex = (
+                        selectedIndex - 1 +
+                        choices.length
+                    ) % choices.length;
+                    render(true);
+                    return;
+                }
+
+                if (key.name === "down") {
+                    selectedIndex = (
+                        selectedIndex + 1
+                    ) % choices.length;
+                    render(true);
+                    return;
+                }
+
+                if (
+                    key.name === "return" ||
+                    key.name === "enter"
+                ) {
+                    const selected =
+                        choices[selectedIndex];
+
+                    cleanup();
+                    output.write("\n");
+                    resolve(selected.value);
+                }
+            };
+
+            console.log(label);
             console.log(
-                `  ${index + 1}) ${labels[value]}`
+                `${ANSI.muted}Use ↑/↓ to move, Enter to select.${ANSI.reset}`
             );
-        }
-    );
 
-    while (true) {
-        const answer =
-            (
-                await prompt.question(
-                    "Authentication (1): "
-                )
-            ).trim();
+            emitKeypressEvents(input);
+            input.on(
+                "keypress",
+                onKeypress
+            );
+            input.setRawMode(true);
+            input.resume();
 
-        if (!answer) {
-            return "none";
-        }
-
-        const index =
-            Number(
-                answer
-            ) - 1;
-
-        if (
-            Number.isInteger(
-                index
-            ) &&
-            index >= 0 &&
-            index <
-                AUTH_CHOICES.length
-        ) {
-            return AUTH_CHOICES[
-                index
-            ];
+            render();
         }
+    );
+}
 
-        const normalized =
-            answer.toLowerCase();
+function printSuccess(
+    result,
+    installed
+) {
+    const relative = path.relative(
+        process.cwd(),
+        result.targetDirectory
+    ) || ".";
 
-        if (
-            AUTH_CHOICES.includes(
-                normalized
-            )
-        ) {
-            return normalized;
-        }
+    console.log("");
+    console.log(
+        `Created BCP app: ${result.projectName}`
+    );
+    console.log(
+        `Location: ${result.targetDirectory}`
+    );
+    console.log(
+        `Tailwind CSS: ${result.tailwind ? "Yes" : "No"}`
+    );
+    console.log(
+        `Database: ${formatDatabaseName(result.database)}`
+    );
+    console.log(
+        `Authentication: ${formatAuthName(result.auth)}`
+    );
+    console.log("");
+    console.log("Next steps:");
+    console.log(
+        `  cd ${quoteIfNeeded(relative)}`
+    );
 
-        console.log(
-            "Choose a number from the list or enter an authentication preset name."
-        );
+    if (!installed) {
+        console.log("  npm install");
     }
+
+    console.log("  npm run dev");
+    console.log("");
 }
 
-function formatDatabaseName(
-    value
-) {
+function formatDatabaseName(value) {
     const names = {
         none: "None",
         mysql: "MySQL",
@@ -568,21 +509,16 @@ function formatDatabaseName(
         mongodb: "MongoDB",
     };
 
-    return names[value] ??
-        value;
+    return names[value] ?? value;
 }
 
-function formatAuthName(
-    value
-) {
+function formatAuthName(value) {
     const names = {
         none: "None",
-        "jwt-cookie":
-            "JWT Cookie",
+        "jwt-cookie": "JWT Cookie",
     };
 
-    return names[value] ??
-        value;
+    return names[value] ?? value;
 }
 
 function printHelp() {
@@ -593,7 +529,8 @@ Usage:
   npx create-bcp-app <project-name> [options]
 
 Interactive setup:
-  - Choose whether to use Tailwind CSS
+  - Use ↑/↓ and Enter for every setup choice
+  - Choose Tailwind CSS: Yes or No
   - Choose a database: None, MySQL, PostgreSQL, SQLite or MongoDB
   - Choose authentication: None or JWT Cookie
 
@@ -613,27 +550,23 @@ Examples:
   npx create-bcp-app my-app --no-tailwind --database mongodb
   npx create-bcp-app my-app --yes
   npx create-bcp-app my-app --no-install
-  npx create-bcp-app my-app --bcp file:../bcp-0.1.8.tgz
 `);
 }
 
-function quoteIfNeeded(
-    value
-) {
-    return /\s/.test(
-        value
-    )
-        ? JSON.stringify(
-            value
-        )
+function quoteIfNeeded(value) {
+    return /\s/.test(value)
+        ? JSON.stringify(value)
         : value;
 }
 
-function fail(
-    message
-) {
+function reportError(error) {
+    const message =
+        error instanceof Error
+            ? error.message
+            : String(error);
+
     console.error(
         `create-bcp-app: ${message}`
     );
-    process.exit(1);
+    process.exitCode = 1;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-bcp-app",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Create a new BCP Framework application.",
   "type": "module",
   "license": "MIT",

package/src/index.d.mts

@@ -28,6 +28,20 @@ export interface CreateBcpAppResult {
     auth: BcpAuthPreset;
 }
 
+export interface ResolveNpmInvocationOptions {
+    env?: Record<
+        string,
+        string | undefined
+    >;
+    platform?: string;
+    execPath?: string;
+}
+
+export interface NpmInvocation {
+    command: string;
+    args: string[];
+}
+
 export function createBcpApp(
     options: CreateBcpAppOptions
 ): Promise<CreateBcpAppResult>;
@@ -35,3 +49,8 @@ export function createBcpApp(
 export function validateProjectName(
     value: unknown
 ): string;
+
+export function resolveNpmInvocation(
+    args: string[],
+    options?: ResolveNpmInvocationOptions
+): NpmInvocation;

package/src/index.mjs

@@ -250,12 +250,9 @@ function copyTemplate(
     sourceDirectory,
     targetDirectory
 ) {
-    fs.cpSync(
+    copyDirectoryContents(
         sourceDirectory,
-        targetDirectory,
-        {
-            recursive: true,
-        }
+        targetDirectory
     );
 
     const gitignoreTemplate =
@@ -279,6 +276,66 @@ function copyTemplate(
     }
 }
 
+function copyDirectoryContents(
+    sourceDirectory,
+    targetDirectory
+) {
+    fs.mkdirSync(
+        targetDirectory,
+        {
+            recursive: true,
+        }
+    );
+
+    const entries =
+        fs.readdirSync(
+            sourceDirectory,
+            {
+                withFileTypes: true,
+            }
+        );
+
+    for (
+        const entry
+        of entries
+    ) {
+        const sourcePath =
+            path.join(
+                sourceDirectory,
+                entry.name
+            );
+        const targetPath =
+            path.join(
+                targetDirectory,
+                entry.name
+            );
+
+        if (
+            entry.isDirectory()
+        ) {
+            copyDirectoryContents(
+                sourcePath,
+                targetPath
+            );
+            continue;
+        }
+
+        if (
+            entry.isFile()
+        ) {
+            fs.copyFileSync(
+                sourcePath,
+                targetPath
+            );
+            continue;
+        }
+
+        throw new Error(
+            `Unsupported template entry: ${sourcePath}`
+        );
+    }
+}
+
 function readPackageMetadata() {
     const packageJson =
         JSON.parse(
@@ -359,8 +416,11 @@ function runInstall(
                     {
                         cwd:
                             targetDirectory,
-                        stdio:
+                        stdio: [
+                            "ignore",
+                            "inherit",
                             "inherit",
+                        ],
                         env:
                             process.env,
                     }
@@ -371,7 +431,7 @@ function runInstall(
                 reject
             );
             child.once(
-                "exit",
+                "close",
                 (
                     code,
                     signal
@@ -396,16 +456,28 @@ function runInstall(
     );
 }
 
-function resolveNpmInvocation(
-    args
+export function resolveNpmInvocation(
+    args,
+    options = {}
 ) {
+    const environment =
+        options.env ??
+        process.env;
+    const platform =
+        options.platform ??
+        process.platform;
+    const execPath =
+        options.execPath ??
+        process.execPath;
     const npmExecPath =
-        process.env.npm_execpath;
+        resolveNpmCliPath(
+            environment.npm_execpath
+        );
 
     if (npmExecPath) {
         return {
             command:
-                process.execPath,
+                execPath,
             args: [
                 npmExecPath,
                 ...args,
@@ -414,11 +486,11 @@ function resolveNpmInvocation(
     }
 
     if (
-        process.platform === "win32"
+        platform === "win32"
     ) {
         return {
             command:
-                process.env.ComSpec ??
+                environment.ComSpec ??
                 "cmd.exe",
             args: [
                 "/d",
@@ -436,3 +508,51 @@ function resolveNpmInvocation(
         args,
     };
 }
+
+function resolveNpmCliPath(
+    npmExecPath
+) {
+    if (
+        typeof npmExecPath !==
+            "string" ||
+        npmExecPath.trim() ===
+            ""
+    ) {
+        return null;
+    }
+
+    const normalized =
+        npmExecPath.trim();
+    const baseName =
+        path.basename(
+            normalized
+        ).toLowerCase();
+
+    if (
+        baseName ===
+        "npm-cli.js"
+    ) {
+        return normalized;
+    }
+
+    if (
+        baseName ===
+        "npx-cli.js"
+    ) {
+        const npmCliPath =
+            path.join(
+                path.dirname(
+                    normalized
+                ),
+                "npm-cli.js"
+            );
+
+        return fs.existsSync(
+            npmCliPath
+        )
+            ? npmCliPath
+            : null;
+    }
+
+    return null;
+}