create-vitnode-app 1.2.0-canary.6 → 1.2.0-canary.60

package/dist/src/helpers/install-dependencies.js

@@ -1,30 +1,71 @@
-import { spawn } from 'child_process';
-import color from 'picocolors';
-import { getOnline } from './is-online.js';
-export const installDependencies = async ({ packageManager: pm, }) => {
-    const packageManager = pm.split('@')[0];
+import { spawn } from "node:child_process";
+import consoleColor from "picocolors";
+import { getOnline } from "./is-online.js";
+function printInstallErrorSuggestions(stderr, color) {
+    if (stderr.includes("ENOTFOUND") || stderr.includes("network")) {
+        console.error(color.yellow("💡 Network error detected. Please check your internet connection."));
+    }
+    else if (stderr.includes("EACCES") ||
+        stderr.includes("permission denied")) {
+        console.error(color.yellow("💡 Permission error detected. Try running with elevated privileges or check file permissions."));
+    }
+    else if (stderr.includes("ENOSPC")) {
+        console.error(color.yellow("💡 Disk space error detected. Please free up some disk space."));
+    }
+    else if (stderr.includes("ERR_PNPM_PEER_DEP_ISSUES")) {
+        console.error(color.yellow("💡 Peer dependency issues detected. Consider using --force flag or resolve conflicts manually."));
+    }
+}
+export const installDependencies = async ({ packageManager: pm, cwd, }) => {
+    const packageManager = pm.split("@")[0];
     const isOnline = await getOnline();
-    const args = packageManager === 'npm' ? ['install', '--force'] : ['install'];
+    const args = ["install"];
     if (!isOnline) {
-        console.log(color.yellow('You appear to be offline.\nFalling back to the local cache.'));
-        args.push('--offline');
+        console.log(consoleColor.yellow("You appear to be offline.\nFalling back to the local cache."));
+        args.push("--offline");
     }
     return new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
         const child = spawn(packageManager, args, {
-            stdio: 'ignore',
+            stdio: "pipe",
+            cwd,
+            shell: true,
             env: {
                 ...process.env,
-                ADBLOCK: '1',
-                NODE_ENV: 'development',
-                DISABLE_OPENCOLLECTIVE: '1',
+                ADBLOCK: "1",
+                NODE_ENV: "development",
+                DISABLE_OPENCOLLECTIVE: "1",
             },
         });
-        child.on('close', code => {
+        child.stdout?.on("data", (data) => {
+            const output = data.toString();
+            stdout += output;
+        });
+        child.stderr?.on("data", (data) => {
+            const output = data.toString();
+            stderr += output;
+        });
+        child.on("close", code => {
             if (code !== 0) {
-                reject({ command: `${packageManager} ${args.join(' ')}` });
+                console.error(consoleColor.red(`\n❌ Installation failed with exit code: ${code}`));
+                if (stderr) {
+                    console.error(consoleColor.red("Error output:"));
+                    console.error(stderr);
+                }
+                if (stdout) {
+                    console.log(consoleColor.yellow("Standard output:"));
+                    console.log(stdout);
+                }
+                printInstallErrorSuggestions(stderr, consoleColor);
+                reject(new Error(`Failed to install dependencies using ${packageManager}. Exit code: ${code}\n${stderr || stdout}`));
                 return;
             }
             resolve();
         });
+        child.on("error", error => {
+            console.error(consoleColor.red(`❌ Failed to start ${packageManager}:`), error.message);
+            reject(new Error(`Failed to start ${packageManager}: ${error.message}`));
+        });
     });
 };

package/dist/src/helpers/is-folder-empty.js

@@ -1,31 +1,30 @@
-import { lstatSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import colors from 'picocolors';
+import { lstatSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import colors from "picocolors";
 export function isFolderEmpty(root, name) {
     const validFiles = [
-        '.DS_Store',
-        '.git',
-        '.gitattributes',
-        '.gitignore',
-        '.gitlab-ci.yml',
-        '.hg',
-        '.hgcheck',
-        '.hgignore',
-        '.idea',
-        '.npmignore',
-        '.travis.yml',
-        'LICENSE',
-        'Thumbs.db',
-        'docs',
-        'mkdocs.yml',
-        'npm-debug.log',
-        'yarn-debug.log',
-        'yarn-error.log',
-        'yarnrc.yml',
-        '.yarn',
+        ".DS_Store",
+        ".git",
+        ".gitattributes",
+        ".gitignore",
+        ".gitlab-ci.yml",
+        ".hg",
+        ".hgcheck",
+        ".hgignore",
+        ".idea",
+        ".npmignore",
+        ".travis.yml",
+        "LICENSE",
+        "Thumbs.db",
+        "docs",
+        "mkdocs.yml",
+        "npm-debug.log",
+        "yarn-debug.log",
+        "yarn-error.log",
+        "yarnrc.yml",
+        ".yarn",
     ];
-    const conflicts = readdirSync(root).filter(file => !validFiles.includes(file) &&
-        !file.endsWith('.iml'));
+    const conflicts = readdirSync(root).filter(file => !(validFiles.includes(file) || file.endsWith(".iml")));
     if (conflicts.length > 0) {
         console.log(`The directory ${colors.green(name)} contains files that could conflict:\n`);
         for (const file of conflicts) {
@@ -42,7 +41,7 @@ export function isFolderEmpty(root, name) {
                 console.log(file);
             }
         }
-        console.log('\nEither try using a new directory name, or remove the files listed above.\n');
+        console.log("\nEither try using a new directory name, or remove the files listed above.\n");
         return false;
     }
     return true;

package/dist/src/helpers/is-online.js

@@ -1,9 +1,21 @@
-import { execSync } from 'child_process';
-import { lookup } from 'dns/promises';
-import { URL } from 'url';
+import { execSync } from "node:child_process";
+import { lookup } from "node:dns/promises";
+import { URL } from "node:url";
+function 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 : undefined;
+    }
+    catch {
+        return;
+    }
+}
 export async function getOnline() {
     try {
-        await lookup('registry.yarnpkg.com');
+        await lookup("registry.yarnpkg.com");
         return true;
     }
     catch {
@@ -24,15 +36,3 @@ export async function getOnline() {
         }
     }
 }
-function 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 : undefined;
-    }
-    catch (_) {
-        return;
-    }
-}

package/dist/src/helpers/is-writeable.js

@@ -1,11 +1,11 @@
-import { W_OK } from 'constants';
-import { access } from 'fs/promises';
+import { W_OK } from "node:constants";
+import { access } from "node:fs/promises";
 export async function isWriteable(directory) {
     try {
         await access(directory, W_OK);
         return true;
     }
-    catch (_) {
+    catch {
         return false;
     }
 }

package/dist/src/helpers/validate-pkg.js

@@ -1,4 +1,4 @@
-import validateProjectName from 'validate-npm-package-name';
+import validateProjectName from "validate-npm-package-name";
 export const validateNpmName = ({ name, }) => {
     const nameValidation = validateProjectName(name);
     if (nameValidation.validForNewPackages) {

package/dist/src/index.js

@@ -1,51 +1,54 @@
 #!/usr/bin/env node
-import { input } from '@inquirer/prompts';
-import { Command, Option } from 'commander';
-import { basename, resolve } from 'path';
-import color from 'picocolors';
-import { createVitNode } from './create/create-vitnode.js';
-import { packageJson } from './helpers/get-package-json.js';
-import { validateNpmName } from './helpers/validate-pkg.js';
-import { createPlugin } from './plugin/index.js';
-import { createQuestionsCli } from './questions.js';
-import { validationProject } from './validation.js';
-const [major] = process.versions.node.split('.').map(Number);
+import { input } from "@inquirer/prompts";
+import { Command, Option } from "commander";
+import { basename, resolve } from "node:path";
+import color from "picocolors";
+import { createVitNode } from "./create/create-vitnode.js";
+import { packageJson } from "./helpers/get-package-json.js";
+import { validateNpmName } from "./helpers/validate-pkg.js";
+import { createPlugin } from "./plugin/index.js";
+import { createQuestionsCli } from "./questions.js";
+import { validationProject } from "./validation.js";
+const [major] = process.versions.node.split(".").map(Number);
 if (major < 20) {
     console.error(color.red(`\nError: VitNode requires Node.js version 20 or higher.\nYou are currently using Node.js ${process.versions.node}\n`));
     process.exit(1);
 }
-process.on('uncaughtException', (error) => {
-    if (error.name === 'ExitPromptError') {
-        console.log(color.dim('👋 VitNode setup cancelled - see you next time!'));
+process.on("uncaughtException", (error) => {
+    if (error.name === "ExitPromptError") {
+        console.log(color.dim("👋 VitNode setup cancelled - see you next time!"));
         process.exit(0);
     }
-    console.error(color.red('An unexpected error occurred:'));
+    console.error(color.red("An unexpected error occurred:"));
     console.error(color.red(error.stack ?? error.message));
     process.exit(1);
 });
 const init = async () => {
-    let projectPath = '';
+    let projectPath = "";
     const program = new Command()
-        .version(packageJson.version)
-        .argument('[project-directory]')
-        .usage(`${color.green('[project-directory]')} [options]`)
+        .version(packageJson.version ?? "0.1.0")
+        .argument("[project-directory]")
+        .usage(`${color.green("[project-directory]")} [options]`)
         .action(name => {
         projectPath = name;
     });
-    program.addOption(new Option('--package-manager <package-manager>', 'Specify the package manager to use').choices(['npm', 'pnpm', 'bun']));
-    program.option('--eslint', 'Initialize with eslint config.');
-    program.option('--skip-install', 'Skip installing packages after initializing the project.');
-    program.option('--plugin', 'Enable plugin mode.');
+    program.addOption(new Option("--package-manager <package-manager>", "Specify the package manager to use").choices(["npm", "pnpm", "bun"]));
+    program.option("--eslint", "Initialize with ESLint & Prettier config.");
+    program.option("--skip-install", "Skip installing packages after initializing the project.");
+    program.addOption(new Option("--mode <mode>", "What type of app do you want to create?").choices(["singleApp", "apiMonorepo", "onlyApi"]));
+    program.option("--monorepo", "Create project with monorepo structure.");
+    program.option("--docker", "Initialize with Docker support.");
+    program.option("--plugin", "Create a plugin.");
     program.parse(process.argv);
     const opts = program.opts();
     if (opts.plugin) {
-        await createPlugin(projectPath);
+        await createPlugin({ projectPath, program });
         return;
     }
     if (!projectPath) {
         projectPath = await input({
-            message: 'What is your project named?',
-            default: 'my-vitnode',
+            message: "What is your project named?",
+            default: "my-vitnode",
             validate: (name) => {
                 const validation = validateNpmName({ name: basename(resolve(name)) });
                 if (validation.valid)

package/dist/src/plugin/create/create-plugin-vitnode.js

@@ -0,0 +1,34 @@
+import { existsSync } from "fs";
+import { mkdir } from "fs/promises";
+import ora from "ora";
+import { dirname, join } from "path";
+import color from "picocolors";
+import { fileURLToPath } from "url";
+import { getPackageManagerFromRoot } from "../../helpers/get-package-manager-from-root.js";
+import { installDependencies } from "../../helpers/install-dependencies.js";
+import { isFolderEmpty } from "../../helpers/is-folder-empty.js";
+export const createPluginVitNode = async ({ pluginPath, pluginName, install, root, }) => {
+    const packageManager = getPackageManagerFromRoot(process.cwd());
+    const spinner = ora(`Creating a new VitNode plugin in ${color.green(pluginPath)}. Using ${color.green(packageManager)}...`).start();
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const templatePath = join(__dirname, "..", "..", "..", "copy-of-vitnode-plugin");
+    if (!existsSync(templatePath)) {
+        spinner.fail(`\n${color.red("Error!")} Template path ${color.cyan(templatePath)} does not exist.`);
+        process.exit(1);
+    }
+    await mkdir(pluginPath, { recursive: true });
+    if (!isFolderEmpty(pluginPath, pluginName)) {
+        process.exit(1);
+    }
+    spinner.text = "Preparing the plugin structure...";
+    spinner.text = "Creating package.json...";
+    if (install) {
+        spinner.text = "Installing dependencies...";
+        await installDependencies({
+            packageManager,
+            cwd: root,
+        });
+    }
+    spinner.succeed(`${color.green("Success!")} Created ${color.cyan(pluginName)} at ${color.cyan(pluginPath)}`);
+};

package/dist/src/plugin/index.js

@@ -1,12 +1,15 @@
-import { input } from '@inquirer/prompts';
-import { basename, resolve } from 'path';
-import { validateNpmName } from '../helpers/validate-pkg.js';
-export const createPlugin = async (projectPath) => {
+import { input } from "@inquirer/prompts";
+import { basename, resolve } from "node:path";
+import { validateNpmName } from "../helpers/validate-pkg.js";
+import { createPluginVitNode } from "./create/create-plugin-vitnode.js";
+import { createPluginQuestionsCli } from "./questions.js";
+import { validationProjectForPlugin } from "./validation.js";
+export const createPlugin = async ({ program, projectPath, }) => {
     let name = projectPath;
     if (!name) {
         name = await input({
-            message: 'What is your plugin named?',
-            default: 'my-vitnode-plugin',
+            message: "What is your plugin named?",
+            default: "my-vitnode-plugin",
             validate: (name) => {
                 const validation = validateNpmName({ name: basename(resolve(name)) });
                 if (validation.valid)
@@ -15,4 +18,12 @@ export const createPlugin = async (projectPath) => {
             },
         });
     }
+    const { pluginName, pluginPath } = await validationProjectForPlugin(name);
+    const options = await createPluginQuestionsCli(program);
+    await createPluginVitNode({
+        pluginName,
+        pluginPath,
+        root: projectPath,
+        ...options,
+    });
 };

package/dist/src/plugin/questions.js

@@ -0,0 +1,14 @@
+import { confirm } from "@inquirer/prompts";
+import color from "picocolors";
+export const createPluginQuestionsCli = async (program) => {
+    const optionsFromProgram = program.opts();
+    const options = {
+        install: !optionsFromProgram.skipInstall,
+    };
+    if (optionsFromProgram.skipInstall === undefined) {
+        options.install = await confirm({
+            message: `Would you like to ${color.blue("Install dependencies")}?`,
+        });
+    }
+    return options;
+};

package/dist/src/plugin/validation.js

@@ -0,0 +1,72 @@
+import { program } from "commander";
+import { existsSync } from "node:fs";
+import { mkdir, readFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import color from "picocolors";
+import { isFolderEmpty } from "../helpers/is-folder-empty.js";
+import { isWriteable } from "../helpers/is-writeable.js";
+import { validateNpmName } from "../helpers/validate-pkg.js";
+export const validationProjectForPlugin = async (projectPath) => {
+    if (!projectPath) {
+        console.log("\nPlease specify the plugin directory:\n" +
+            `  ${color.cyan(program.name())} ${color.green("<plugin-directory>")}\n` +
+            "For example:\n" +
+            `  ${color.cyan(program.name())} ${color.green("my-vitnode-plugin")}\n\n` +
+            `Run ${color.cyan(`${program.name()} --help`)} to see all options.`);
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    const turboJsonPath = join(cwd, "turbo.json");
+    const packageJsonPath = join(cwd, "package.json");
+    if (!existsSync(turboJsonPath)) {
+        console.error(`${color.red("Error:")} Could not find ${color.cyan("turbo.json")} in the current directory.`);
+        console.error(`Plugins must be created inside a VitNode monorepo structure.`);
+        console.error(`\nPlease run this command from the root of your VitNode monorepo project.`);
+        process.exit(1);
+    }
+    if (!existsSync(packageJsonPath)) {
+        console.error(`${color.red("Error:")} Could not find ${color.cyan("package.json")} in the current directory.`);
+        console.error(`\nPlease run this command from the root of your VitNode monorepo project.`);
+        process.exit(1);
+    }
+    try {
+        const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+        if (!packageJson.packageManager) {
+            console.error(`${color.red("Error:")} The ${color.cyan("packageManager")} field is not defined in ${color.cyan("package.json")}.`);
+            console.error(`\nPlease add a ${color.cyan('"packageManager"')} field to your ${color.cyan("package.json")} file.`);
+            console.error(`Example: ${color.green('"packageManager": "pnpm@10.18.3"')}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`${color.red("Error:")} Failed to read or parse ${color.cyan("package.json")}.`);
+        console.error(error);
+        process.exit(1);
+    }
+    const projectName = basename(resolve(projectPath));
+    const validation = validateNpmName({ name: projectName });
+    if (!validation.valid) {
+        console.error(`Could not create a plugin called ${color.red(`"${projectName}"`)} because of npm naming restrictions:`);
+        validation.problems.forEach(p => {
+            console.error(`${color.red(color.bold("*"))} ${p}`);
+        });
+        process.exit(1);
+    }
+    const pluginsDir = join(cwd, "plugins");
+    const pluginPath = join(pluginsDir, projectName);
+    const pluginName = basename(pluginPath);
+    const folderExists = existsSync(pluginPath);
+    if (folderExists && !isFolderEmpty(pluginPath, pluginName)) {
+        console.error(`The directory ${color.cyan(`plugins/${pluginName}`)} is not empty.`);
+        process.exit(1);
+    }
+    if (!existsSync(pluginsDir)) {
+        await mkdir(pluginsDir, { recursive: true });
+    }
+    if (!(await isWriteable(pluginsDir))) {
+        console.error(`The plugins directory is not writable, please check folder permissions and try again.`);
+        console.error(`It is likely you do not have write permissions for this folder.`);
+        process.exit(1);
+    }
+    return { pluginName, pluginPath };
+};

package/dist/src/prepare/prepare.js

@@ -1,12 +1,12 @@
-import { existsSync } from 'fs';
-import { mkdir } from 'fs/promises';
-import { join } from 'path';
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
 const prepare = async () => {
-    const toRootPath = join(process.cwd(), 'copy-of-vitnode-app');
+    const toRootPath = join(process.cwd(), "copy-of-vitnode-app");
     if (!existsSync(toRootPath)) {
         await mkdir(toRootPath);
     }
-    const fromRootPath = join(process.cwd(), '..', '..', 'apps', 'web');
+    const fromRootPath = join(process.cwd(), "..", "..", "apps", "docs");
     if (!existsSync(fromRootPath)) {
         console.error(`\x1b[31mThe path ${fromRootPath} does not exist. Please check the directory structure.\x1b[0m`);
         process.exit(1);

package/dist/src/questions.js

@@ -1,45 +1,82 @@
-import { select } from '@inquirer/prompts';
-import { confirm } from '@inquirer/prompts';
-import color from 'picocolors';
-import { getAvailablePackageManagers } from './helpers/get-available-package-managers.js';
+import { confirm, select } from "@inquirer/prompts";
+import color from "picocolors";
+import { getAvailablePackageManagers } from "./helpers/get-available-package-managers.js";
 export const createQuestionsCli = async (program) => {
     const optionsFromProgram = program.opts();
     const options = {
         packageManager: optionsFromProgram.packageManager,
         eslint: optionsFromProgram.eslint,
         install: !optionsFromProgram.skipInstall,
+        docker: optionsFromProgram.docker,
+        mode: optionsFromProgram.mode,
+        monorepo: optionsFromProgram.monorepo,
     };
     if (!optionsFromProgram.packageManager) {
         const availablePackageManagers = await getAvailablePackageManagers();
         options.packageManager = await select({
-            message: `Which ${color.blue('package manager')} do you want to use?`,
+            message: `Which ${color.blue("package manager")} do you want to use?`,
             choices: [
                 {
-                    name: `npm${availablePackageManagers.npm ? `@${availablePackageManagers.npm}` : ''}`,
-                    value: 'npm',
-                    disabled: !availablePackageManagers.npm,
+                    name: `bun${availablePackageManagers.bun ? `@${availablePackageManagers.bun}` : ""}`,
+                    value: "bun",
+                    disabled: !availablePackageManagers.bun,
                 },
                 {
-                    name: `pnpm${availablePackageManagers.pnpm ? `@${availablePackageManagers.pnpm}` : ''}`,
-                    value: 'pnpm',
+                    name: `pnpm${availablePackageManagers.pnpm ? `@${availablePackageManagers.pnpm}` : ""}`,
+                    value: "pnpm",
                     disabled: !availablePackageManagers.pnpm,
                 },
                 {
-                    name: `bun${availablePackageManagers.bun ? `@${availablePackageManagers.bun}` : ''}`,
-                    value: 'bun',
-                    disabled: !availablePackageManagers.bun,
+                    name: `npm${availablePackageManagers.npm ? `@${availablePackageManagers.npm}` : ""}`,
+                    value: "npm",
+                    disabled: !availablePackageManagers.npm,
+                },
+            ],
+        });
+    }
+    if (optionsFromProgram.mode === undefined) {
+        options.mode = await select({
+            message: `What type of ${color.blue("app")} do you want to create?`,
+            choices: [
+                {
+                    name: `Single App - ${color.blue("Next.js")} & ${color.blue("Hono.js")}`,
+                    description: "Create a single app with Next.js and Hono.js in the same project.",
+                    value: "singleApp",
+                },
+                {
+                    name: `Monorepo App - ${color.blue("Next.js")} & ${color.blue("Hono.js")}`,
+                    description: "Create a monorepo with both Next.js and Hono.js apps separately.",
+                    value: "apiMonorepo",
+                },
+                {
+                    name: `Only API - ${color.blue("Hono.js")}`,
+                    description: "Create only an API app using Hono.js without Next.js.",
+                    value: "onlyApi",
                 },
             ],
+            default: "singleApp",
+        });
+    }
+    if (optionsFromProgram.monorepo === undefined &&
+        options.mode !== "apiMonorepo") {
+        options.monorepo = await confirm({
+            message: `Would you like to use ${color.blue("TurboRepo")} for monorepo management? ${color.red("(Required for plugins development)")}`,
+            default: false,
         });
     }
     if (optionsFromProgram.eslint === undefined) {
         options.eslint = await confirm({
-            message: `Would you like to use ${color.blue('ESLint')}?`,
+            message: `Would you like to use ${color.blue("ESLint & Prettier")}?`,
+        });
+    }
+    if (optionsFromProgram.docker === undefined) {
+        options.docker = await confirm({
+            message: `Would you like to use ${color.blue("Docker Container")}?`,
         });
     }
     if (optionsFromProgram.skipInstall === undefined) {
         options.install = await confirm({
-            message: `Would you like to ${color.blue('Install dependencies')}?`,
+            message: `Would you like to ${color.blue("Install dependencies")}?`,
         });
     }
     return options;

package/dist/src/validation.js

@@ -1,16 +1,16 @@
-import { program } from 'commander';
-import { existsSync } from 'fs';
-import { basename, dirname, resolve } from 'path';
-import color from 'picocolors';
-import { isFolderEmpty } from './helpers/is-folder-empty.js';
-import { isWriteable } from './helpers/is-writeable.js';
-import { validateNpmName } from './helpers/validate-pkg.js';
+import { program } from "commander";
+import { existsSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+import color from "picocolors";
+import { isFolderEmpty } from "./helpers/is-folder-empty.js";
+import { isWriteable } from "./helpers/is-writeable.js";
+import { validateNpmName } from "./helpers/validate-pkg.js";
 export const validationProject = async (projectPath) => {
     if (!projectPath) {
-        console.log('\nPlease specify the project directory:\n' +
-            `  ${color.cyan(program.name())} ${color.green('<project-directory>')}\n` +
-            'For example:\n' +
-            `  ${color.cyan(program.name())} ${color.green('my-vitnode-app')}\n\n` +
+        console.log("\nPlease specify the project directory:\n" +
+            `  ${color.cyan(program.name())} ${color.green("<project-directory>")}\n` +
+            "For example:\n" +
+            `  ${color.cyan(program.name())} ${color.green("my-vitnode-app")}\n\n` +
             `Run ${color.cyan(`${program.name()} --help`)} to see all options.`);
         process.exit(1);
     }
@@ -20,7 +20,7 @@ export const validationProject = async (projectPath) => {
     if (!validation.valid) {
         console.error(`Could not create a project called ${color.red(`"${projectName}"`)} because of npm naming restrictions:`);
         validation.problems.forEach(p => {
-            console.error(`${color.red(color.bold('*'))} ${p}`);
+            console.error(`${color.red(color.bold("*"))} ${p}`);
         });
         process.exit(1);
     }
@@ -28,12 +28,12 @@ export const validationProject = async (projectPath) => {
     const appName = basename(root);
     const folderExists = existsSync(root);
     if (folderExists && !isFolderEmpty(root, appName)) {
-        console.error('The specified directory is not empty.');
+        console.error("The specified directory is not empty.");
         process.exit(1);
     }
     if (!(await isWriteable(dirname(root)))) {
-        console.error('The application path is not writable, please check folder permissions and try again.');
-        console.error('It is likely you do not have write permissions for this folder.');
+        console.error("The application path is not writable, please check folder permissions and try again.");
+        console.error("It is likely you do not have write permissions for this folder.");
         process.exit(1);
     }
     return { appName, root };