create-webiny-project 0.0.0-ee-vpcs.549378cf03

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# create-webiny-project
+
+[![](https://img.shields.io/npm/dw/create-webiny-project.svg)](https://www.npmjs.com/package/create-webiny-project)
+[![](https://img.shields.io/npm/v/create-webiny-project.svg)](https://www.npmjs.com/package/create-webiny-project)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+A tool for setting up a new Webiny project.
+
+## Usage
+
+#### Simple:
+
+```
+npx create-webiny-project@beta my-test-project --tag beta
+```
+
+#### Advanced:
+
+```
+npx create-webiny-project@beta my-test-project
+          --tag beta --no-interactive
+          --assign-to-yarnrc '{"npmRegistryServer":"http://localhost:4873","unsafeHttpWhitelist":["localhost"]}'
+          --template-options '{"region":"eu-central-1","vpc":false}'
+```
+
+This usage is more ideal for CI/CD environments, where interactivity is not available.
+
+But do note that this is probably more useful to us, Webiny developers, than for actual Webiny projects. This is simply because in real project's CI/CD pipelines, users would simply start off by cloning the project from their private repository, and not create a new one with the above command.
+
+## Development Notes
+
+Testing this, and related packages (like [cwp-template-aws](./../cwp-template-aws)) is a bit complicated, because in order to get the best results, it's recommended to test everything with packages published to a real NPM.
+
+But of course, publishing to NPM just to test something is not ideal, and that's why, we use [Verdaccio](https://verdaccio.org/) instead, which is, basically, an NPM-like service you can run locally. So, instead of publishing packages to NPM, you publish them to Verdaccio, which is much cleaner, because everything stays on your laptop.
+
+#### Usage
+
+So, you've made some changes, and now you'd like to see the `create-webiny-project` in action.
+
+The following steps show how to do it.
+
+#### 1. Start Verdaccio
+
+Start by running the `yarn verdaccio:start` command, which will, as the script name itself suggests, spin up Verdaccio locally.
+
+> All of the files uploaded to Verdaccio service will be stored in the `.verdaccio` folder, located in your project root.
+
+#### 2. Set default NPM registry
+
+Once you have Verdaccio up and running, you'll also need to change the default NPM registry. Meaning, when you run `npx create-webiny-project ...`, you want it to start fetching packages from Verdaccio, not real NPM. Verdaccio runs on localhost, on port 4873, so, in your terminal, run the following command:
+
+```
+npm config set registry http://localhost:4873
+```
+
+Note that this will only help you with `npx`, but won't help you when a new project foundation is created, and the dependencies start to get pulled. This is because we're using yarn2, which actually doesn't respect the values that were written by the `npm config set ...` command we just executed.
+
+It's super important that, when you're testing your npx project, you also pass the following argument:
+
+```
+--assign-to-yarnrc '{"npmRegistryServer":"http://localhost:4873","unsafeHttpWhitelist":["localhost"]}'
+```
+
+This will set the necessary values in yarn2 config file, which will be located in your newly created project. But don't worry about it right now, this will be revisited in step 4.
+
+> Yarn2 projects don't rely on global configurations and is not installed globally, but on per-project basis. This allows having multiple versions of yarn2, for different projects.
+
+#### 3. Release
+
+Commit (no need to push it if you don't want to) all of the code changes, and execute the following command:
+
+
+```bash
+yarn release --type=verdaccio
+```
+
+#### 4. Test
+
+Test your changes with the following command:
+
+```
+npx create-webiny-project@next my-test-project --tag next --assign-to-yarnrc '{"npmRegistryServer":"http://localhost:4873","unsafeHttpWhitelist":["localhost"]}'
+```
+
+This should create a project, with all of the packages pulled from Verdaccio.
+
+#### 5. Cleanup
+
+Once you're done, do the following:
+
+1. Reset NPM registry with `npm config set registry https://registry.npmjs.org/`
+2. Remove `.verdaccio` folder
+
+### Commands Cheat Sheet
+
+| Description                                   | Command                                                                                                                                                            |
+|-----------------------------------------------| ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Remove `.verdaccio` folder                    | `rm -rf .verdaccio`                                                                                                                                                |
+| List all v5\* tags                            | `git tag -l "v5*"`                                                                                                                                                 |
+| Remove specific tag                           | `git tag -d "v5.0.0-next.5"`                                                                                                                                       |
+| Set Verdaccio as the NPM registry             | `npm config set registry http://localhost:4873`                                                                                                                    |
+| Reset NPM registry                            | `npm config set registry https://registry.npmjs.org/`                                                                                                              |
+| Start Verdaccio                               | `yarn verdaccio:start`                                                                                                                                             |
+| Release to Verdaccio | `yarn release --type=verdaccio`                                                                                                     |
+| Create a new Webiny project                   | `npx create-webiny-project@next my-test-project --tag next --assign-to-yarnrc '{"npmRegistryServer":"http://localhost:4873","unsafeHttpWhitelist":["localhost"]}'` |
+| Revert versioning commit                      | `git reset HEAD~ && git reset --hard HEAD`                                                                                                                         |
+
+## Troubleshooting
+
+#### I made a new release to Verdaccio, but I still receive old code.
+
+This is probably because of one of the Yarn package caching mechanisms.
+
+Yarn has two levels of cache - local and shared. 
+
+When you install a package, it gets cached in the local cache folder (located in your project), and in the shared cache folder. This makes it much faster when you're working on a couple of projects on your local machine, and you're pulling the same package in each. If the package doesn't exist in local cache, it will be pulled from shared cache. 
+
+On Windows, the shared cache folder should be located in: `C:\Users\{USER-NAME}\AppData\Local\Yarn`. 
+On Linux/Mac, the shared cache folder should be located in: `/Users/adrian/Library/Caches/Yarn`.
+
+In these folders, most probably, you'll also have the `\Berry\cache` folder. But, there were also cases where this folder did not exist.
+
+Deleting the mentioned cache folders should help with the issue of still receiving old packages in your testing sessions.
+
+With all of this being said, you can also try the [following command](https://yarnpkg.com/features/offline-cache#cleaning-the-cache):
+
+```bash
+yarn cache clean --mirror
+````

package/bin.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+"use strict";
+
+const semver = require("semver");
+const chalk = require("chalk");
+const getYarnVersion = require("./utils/getYarnVersion");
+const verifyConfig = require("./utils/verifyConfig");
+
+(async () => {
+    const nodeVersion = process.versions.node;
+    if (!semver.satisfies(nodeVersion, ">=14")) {
+        console.error(
+            chalk.red(
+                [
+                    `You are running Node.js ${nodeVersion}, but Webiny requires version 14 or higher.`,
+                    `Please switch to one of the required versions and try again.`,
+                    "For more information, please visit https://docs.webiny.com/docs/tutorials/install-webiny#prerequisites."
+                ].join(" ")
+            )
+        );
+        process.exit(1);
+    }
+
+    try {
+        const yarnVersion = await getYarnVersion();
+        if (!semver.satisfies(yarnVersion, ">=1.22.0")) {
+            console.error(
+                chalk.red(
+                    [
+                        `Webiny requires yarn@^1.22.0 or higher.`,
+                        `Please visit https://yarnpkg.com/ to install ${chalk.green("yarn")}.`
+                    ].join("\n")
+                )
+            );
+            process.exit(1);
+        }
+    } catch (err) {
+        console.error(
+            chalk.red(`Webiny depends on "yarn" and its built-in support for workspaces.`)
+        );
+
+        console.log(`Please visit https://yarnpkg.com/ to install ${chalk.green("yarn")}.`);
+
+        process.exit(1);
+    }
+
+    await verifyConfig();
+    require("./index");
+})();

package/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+const yargs = require("yargs");
+const packageJson = require("./package.json");
+const createProject = require("./utils/createProject");
+
+process.on("unhandledRejection", err => {
+    throw err;
+});
+
+yargs
+    .usage("Usage: create-webiny-project <project-name> [options]")
+    .version(packageJson.version)
+    .demandCommand(1)
+    .help()
+    .alias("help", "h")
+    .scriptName("create-webiny-project")
+    .fail(function (msg, err) {
+        if (msg) {
+            console.log(msg);
+        }
+        if (err) {
+            console.log(err);
+        }
+        process.exit(1);
+    });
+
+// noinspection BadExpressionStatementJS
+yargs.command(
+    "$0 <project-name> [options]",
+    "Name of application and template to use",
+    yargs => {
+        yargs.positional("project-name", {
+            describe: "Project name"
+        });
+        yargs.option("force", {
+            describe: "All project creation within an existing folder",
+            default: false,
+            type: "boolean",
+            demandOption: false
+        });
+        yargs.option("template", {
+            describe: `Name of template to use, if no template is provided it will default to "aws" template`,
+            alias: "t",
+            type: "string",
+            default: "aws",
+            demandOption: false
+        });
+        yargs.option("template-options", {
+            describe: `A JSON containing template-specific options (usually used in non-interactive environments)`,
+            default: null,
+            type: "string",
+            demandOption: false
+        });
+        yargs.option("assign-to-yarnrc", {
+            describe: `A JSON containing additional options that will be assigned into the "yarnrc.yml" configuration file`,
+            default: null,
+            type: "string",
+            demandOption: false
+        });
+        yargs.option("tag", {
+            describe: "NPM tag to use for @webiny packages",
+            type: "string",
+            default: "latest",
+            demandOption: false
+        });
+        yargs.option("interactive", {
+            describe: "Enable interactive mode for all commands",
+            default: true,
+            type: "boolean",
+            demandOption: false
+        });
+        yargs.option("log", {
+            describe:
+                "Creates a log file to see output of installation. Defaults to creating cwp-logs.txt in current directory",
+            alias: "l",
+            default: "cwp-logs.txt",
+            type: "string",
+            demandOption: false
+        });
+        yargs.option("cleanup", {
+            describe: "If an error occurs upon project creation, deletes all generated files",
+            alias: "c",
+            default: true,
+            type: "boolean",
+            demandOption: false
+        });
+
+        yargs.example("$0 <project-name>");
+        yargs.example("$0 <project-name> --template=aws");
+        yargs.example("$0 <project-name> --template=../path/to/template");
+        yargs.example("$0 <project-name> --log=./my-logs.txt");
+    },
+    argv => createProject(argv)
+).argv;

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "create-webiny-project",
+	"version": "0.0.0-ee-vpcs.549378cf03",
+	"description": "Webiny project bootstrap tool.",
+	"main": "index.js",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1"
+	},
+	"bin": "./bin.js",
+	"keywords": [
+		"Webiny"
+	],
+	"author": "Webiny Ltd.",
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/telemetry": "0.0.0-ee-vpcs.549378cf03",
+		"chalk": "4.1.0",
+		"execa": "5.1.1",
+		"find-up": "5.0.0",
+		"fs-extra": "9.1.0",
+		"js-yaml": "3.14.1",
+		"listr": "0.14.3",
+		"load-json-file": "6.2.0",
+		"node-fetch": "2.6.1",
+		"os": "0.1.1",
+		"p-retry": "4.2.0",
+		"rimraf": "3.0.2",
+		"semver": "7.3.8",
+		"uuid": "8.3.2",
+		"validate-npm-package-name": "3.0.0",
+		"write-json-file": "4.3.0",
+		"yargs": "17.6.0"
+	},
+	"publishConfig": {
+		"access": "public",
+		"directory": "."
+	},
+	"gitHead": "549378cf03fcd27845fc3fa23d1dc6b32896f630"
+}

package/utils/checkProjectName.js

@@ -0,0 +1,22 @@
+const { red, green } = require("chalk");
+const validateProjectName = require("validate-npm-package-name");
+
+module.exports = projectName => {
+    const validationResult = validateProjectName(projectName);
+    if (!validationResult.validForNewPackages) {
+        console.error(
+            red(
+                `Cannot create a project named ${green(
+                    `"${projectName}"`
+                )} because of npm naming restrictions:\n`
+            )
+        );
+        [...(validationResult.errors || []), ...(validationResult.warnings || [])].forEach(
+            error => {
+                console.error(red(`  * ${error}`));
+            }
+        );
+        console.error(red("\nPlease choose a different project name."));
+        process.exit(1);
+    }
+};

package/utils/createProject.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+const { yellow, red, green, gray } = require("chalk");
+const execa = require("execa");
+const fs = require("fs-extra");
+const Listr = require("listr");
+const path = require("path");
+const writeJson = require("write-json-file");
+const rimraf = require("rimraf");
+const { sendEvent } = require("@webiny/telemetry/cli");
+const getPackageJson = require("./getPackageJson");
+const checkProjectName = require("./checkProjectName");
+const yaml = require("js-yaml");
+const findUp = require("find-up");
+
+const NOT_APPLICABLE = gray("N/A");
+
+module.exports = async function createProject({
+    projectName,
+    force,
+    template,
+    tag,
+    log,
+    cleanup,
+    interactive,
+    templateOptions,
+    assignToYarnrc: assignToYarnRc
+}) {
+    if (!projectName) {
+        throw Error("You must provide a name for the project to use.");
+    }
+
+    const projectRoot = path.resolve(projectName).replace(/\\/g, "/");
+    projectName = path.basename(projectRoot);
+
+    if (fs.existsSync(projectRoot)) {
+        if (!force) {
+            console.log(
+                `Cannot continue because the target folder ${red(projectName)} already exists.`
+            );
+            console.log(
+                `If you still wish to proceed, run the same command with the ${red(
+                    "--force"
+                )} flag.`
+            );
+            process.exit(1);
+        }
+    }
+
+    // Before create any files, check if there are yarn.lock or package.json anywhere up in the tree.
+    await Promise.all([findUp("yarn.lock"), findUp("package.json")])
+        .then(files => files.filter(Boolean))
+        .then(files => {
+            if (files.length) {
+                const messages = [
+                    "\nThe following file(s) will cause problems with project root detection:\n",
+                    ...files.map(file => red(file) + "\n"),
+                    `\nMake sure you delete all ${red("yarn.lock")} and ${red(
+                        "package.json"
+                    )} files higher in the hierarchy.`
+                ];
+
+                console.log(messages.join(""));
+                process.exit(1);
+            }
+        });
+
+    // Check if @webiny/cli is installed globally and warn user
+    try {
+        await execa("npm", ["list", "-g", "@webiny/cli"]);
+        console.log(
+            [
+                "",
+                "🚨 IMPORTANT NOTICE:",
+                "----------------------------------------",
+                `We've detected a global installation of ${green(
+                    "@webiny/cli"
+                )}. This might not play well with your new project.`,
+                `We recommend you do one of the following things:\n`,
+                ` - uninstall the global @webiny/cli package by running ${green(
+                    "npm rm -g @webiny/cli"
+                )} or`,
+                ` - run webiny commands using ${green(
+                    "yarn webiny"
+                )} so that the package is always resolved to your project dependencies\n`,
+                `The second option is also recommended if you have an older version of Webiny project you want to keep using.`,
+                "----------------------------------------",
+                ""
+            ].join("\n")
+        );
+    } catch (err) {
+        // @webiny/cli is not installed globally
+    }
+
+    console.log(`Initializing a new Webiny project in ${green(projectRoot)}...`);
+
+    await sendEvent({ event: "create-webiny-project-start" });
+
+    let isGitAvailable = false;
+    try {
+        await execa("git", ["--version"]);
+        isGitAvailable = true;
+    } catch {
+        // Git is not available.
+    }
+
+    const tasks = new Listr(
+        [
+            {
+                // Creates root package.json.
+                title: "Prepare project folder",
+                task: () => {
+                    checkProjectName(projectName);
+                    fs.ensureDirSync(projectName);
+                    writeJson.sync(
+                        path.join(projectRoot, "package.json"),
+                        getPackageJson(projectName)
+                    );
+                }
+            },
+            {
+                // Setup yarn
+                title: "Setup yarn",
+                task: async () => {
+                    await execa("yarn", ["set", "version", "berry"], { cwd: projectRoot });
+
+                    const yamlPath = path.join(projectRoot, ".yarnrc.yml");
+                    const parsedYaml = yaml.load(fs.readFileSync(yamlPath, "utf-8"));
+
+                    // Default settings are applied here. Currently we only apply the `nodeLinker` param.
+                    parsedYaml.nodeLinker = "node-modules";
+
+                    // Enables adding additional params into the `.yarnrc.yml` file.
+                    if (assignToYarnRc) {
+                        let parsedAssignToYarnRc;
+                        try {
+                            parsedAssignToYarnRc = JSON.parse(assignToYarnRc);
+                        } catch {
+                            console.log(
+                                yellow("Warning: could not parse provided --assign-to-yarnrc JSON.")
+                            );
+                        }
+
+                        if (parsedAssignToYarnRc) {
+                            Object.assign(parsedYaml, parsedAssignToYarnRc);
+                        }
+                    }
+
+                    fs.writeFileSync(yamlPath, yaml.dump(parsedYaml));
+                }
+            },
+            {
+                // "yarn adds" given template which can be either a real package or a path of a local package.
+                title: `Install template package`,
+                task: async context => {
+                    let add;
+                    let templateName = `@webiny/cwp-template-${template}`;
+
+                    if (template.startsWith(".") || template.startsWith("file:")) {
+                        templateName =
+                            "file:" + path.relative(projectName, template.replace("file:", ""));
+                        add = templateName;
+                    } else {
+                        add = `${templateName}@${tag}`;
+                    }
+
+                    // Assign template name to context.
+                    context.templateName = templateName;
+
+                    await execa("yarn", ["add", add], { cwd: projectRoot });
+                }
+            },
+            isGitAvailable
+                ? {
+                      // Initialize `git` by executing `git init` in project directory.
+                      title: `Initialize git`,
+                      task: (ctx, task) => {
+                          try {
+                              execa.sync("git", ["--version"]);
+                              execa.sync("git", ["init"], { cwd: projectRoot });
+                              fs.writeFileSync(
+                                  path.join(projectRoot, ".gitignore"),
+                                  "node_modules/"
+                              );
+                          } catch (err) {
+                              task.skip("Git repo not initialized", err);
+                          }
+                      }
+                  }
+                : null
+        ].filter(Boolean)
+    );
+
+    // The `context` object will be filled with additional values in the `tasks.run` process.
+    const context = {};
+
+    try {
+        await tasks.run(context);
+
+        let templateName = context.templateName;
+
+        console.log(`Starting ${green(templateName)} template ...`);
+        if (templateName.startsWith("file:")) {
+            templateName = templateName.replace("file:", "");
+        }
+
+        const templatePath = path.dirname(
+            require.resolve(path.join(templateName, "package.json"), {
+                paths: [projectRoot]
+            })
+        );
+
+        await new Promise(resolve => {
+            setTimeout(() => {
+                resolve();
+            }, 500);
+        });
+
+        let parsedTemplateOptions = {};
+        if (templateOptions) {
+            try {
+                parsedTemplateOptions = JSON.parse(templateOptions);
+            } catch {
+                console.log(yellow("Warning: could not parse provided --template-options JSON."));
+            }
+        }
+
+        console.log();
+        await require(templatePath)({
+            log,
+            isGitAvailable,
+            projectName,
+            projectRoot,
+            interactive,
+            templateOptions: parsedTemplateOptions
+        });
+
+        await sendEvent({ event: "create-webiny-project-end" });
+    } catch (err) {
+        await sendEvent({
+            event: "create-webiny-project-error",
+            properties: {
+                errorMessage: err.message,
+                errorStack: err.stack
+            }
+        });
+
+        const node = process.versions.node;
+        const os = process.platform;
+
+        let yarn = NOT_APPLICABLE;
+        try {
+            const subprocess = await execa("yarn", ["--version"], { cwd: projectRoot });
+            yarn = subprocess.stdout;
+        } catch {}
+
+        let cwp = NOT_APPLICABLE;
+        try {
+            const subprocess = await execa("npx", ["create-webiny-project", "--version"]);
+            cwp = subprocess.stdout;
+        } catch {}
+
+        let cwpTemplate = NOT_APPLICABLE;
+        try {
+            const subprocess = await execa("yarn", ["info", "@webiny/cwp-template-aws", "--json"], {
+                cwd: projectRoot
+            });
+            const data = JSON.parse(subprocess.stdout);
+            cwpTemplate = `@webiny/cwp-template-${template}@${data.children.Version}`;
+        } catch {}
+
+        let templateOptionsJson = "{}";
+        if (templateOptions) {
+            try {
+                templateOptionsJson = JSON.stringify(templateOptions);
+            } catch {}
+        }
+
+        console.log(
+            [
+                "",
+                `${green("ERROR OUTPUT: ")}`,
+                "----------------------------------------",
+                err.message,
+                "",
+                `${green("SYSTEM INFORMATION: ")}`,
+                "----------------------------------------",
+                `Operating System: ${os}`,
+                `Node: ${node}`,
+                `Yarn: ${yarn}`,
+                `create-webiny-project: ${cwp}`,
+                `Template: ${cwpTemplate}`,
+                `Template Options: ${templateOptionsJson}`,
+                "",
+                "Please open an issue including the error output at https://github.com/webiny/webiny-js/issues/new.",
+                "You can also get in touch with us on our Slack Community: https://www.webiny.com/slack",
+                ""
+            ].join("\n")
+        );
+
+        console.log(`Writing log to ${green(path.resolve(log))}...`);
+        fs.writeFileSync(path.resolve(log), err.toString());
+
+        if (cleanup) {
+            console.log("Cleaning up generated files and folders...");
+            rimraf.sync(projectRoot);
+            console.log("Done.");
+        } else {
+            console.log("Project cleanup skipped.");
+        }
+
+        await sendEvent({ event: "create-webiny-project-end" });
+        process.exit(1);
+    }
+};

package/utils/getPackageJson.js

@@ -0,0 +1,5 @@
+module.exports = projectName => ({
+    name: projectName,
+    version: "0.1.0",
+    private: true
+});

package/utils/getPackageVersion.js

@@ -0,0 +1,24 @@
+const fetch = require("node-fetch");
+const pRetry = require("p-retry");
+const semver = require("semver");
+const execa = require("execa");
+
+module.exports = function getPackageVersion(name, tag = "latest") {
+    if (semver.valid(tag)) {
+        return tag;
+    }
+    const getVersion = async () => {
+        const { stdout: registry } = await execa("npm", ["config", "get", "registry"]);
+        const res = await fetch(`${registry}${name}`);
+        const json = await res.json();
+
+        const tagVersion = json["dist-tags"][tag];
+        if (!tagVersion || semver.lte(tagVersion, json["dist-tags"]["latest"])) {
+            return json["dist-tags"]["latest"];
+        }
+
+        return tagVersion;
+    };
+
+    return pRetry(getVersion, { retries: 5 });
+};

package/utils/getYarnVersion.js

@@ -0,0 +1,10 @@
+const execa = require("execa");
+
+module.exports = async () => {
+    try {
+        const { stdout } = await execa("yarn", ["--version"]);
+        return stdout;
+    } catch (err) {
+        return "";
+    }
+};

package/utils/verifyConfig.js

@@ -0,0 +1,20 @@
+const os = require("os");
+const path = require("path");
+const readJson = require("load-json-file");
+const writeJson = require("write-json-file");
+
+const configPath = path.join(os.homedir(), ".webiny", "config");
+
+module.exports = async () => {
+    // Check user ID
+    try {
+        const config = await readJson(configPath);
+        if (!config.id) {
+            throw Error("Invalid Webiny config!");
+        }
+    } catch (e) {
+        const { v4: uuidv4 } = require("uuid");
+        // A new config file is written if it doesn't exist or is invalid.
+        writeJson.sync(configPath, { id: uuidv4(), telemetry: true });
+    }
+};