wrangler 0.0.0-e95bea2 → 0.0.0-e95e5a0

package/src/index.tsx

@@ -3,19 +3,24 @@ import { writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
 import { setTimeout } from "node:timers/promises";
 import TOML from "@iarna/toml";
+import chalk from "chalk";
+import { execa } from "execa";
 import { findUp } from "find-up";
 import getPort from "get-port";
 import { render } from "ink";
 import React from "react";
 import onExit from "signal-exit";
+import supportsColor from "supports-color";
 import makeCLI from "yargs";
 import { version as wranglerVersion } from "../package.json";
 import { fetchResult } from "./cfetch";
 import { findWranglerToml, readConfig } from "./config";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
 import Dev from "./dev/dev";
+import { getVarsForDev } from "./dev/dev-vars";
 import { confirm, prompt } from "./dialogs";
 import { getEntry } from "./entry";
+import { DeprecationError } from "./errors";
 import {
   getNamespaceId,
   listNamespaces,
@@ -29,9 +34,16 @@ import {
   isKeyValue,
   unexpectedKeyValueProps,
 } from "./kv";
+import { logger } from "./logger";
 import { getPackageManager } from "./package-manager";
-import { pages } from "./pages";
-import { formatMessage, ParseError, parseJSON, readFileSync } from "./parse";
+import { pages, pagesBetaWarning } from "./pages";
+import {
+  formatMessage,
+  ParseError,
+  parseJSON,
+  parseTOML,
+  readFileSync,
+} from "./parse";
 import publish from "./publish";
 import { createR2Bucket, deleteR2Bucket, listR2Buckets } from "./r2";
 import { getAssetPaths } from "./sites";
@@ -41,14 +53,13 @@ import {
   prettyPrintLogs,
   translateCLICommandToFilterMessage,
 } from "./tail";
+import { updateCheck } from "./update-check";
 import {
   login,
   logout,
   listScopes,
-  initialise as initialiseUserConfig,
-  loginOrRefreshIfRequired,
-  getAccountId,
   validateScopeKeys,
+  requireAuth,
 } from "./user";
 import { whoami } from "./whoami";
 
@@ -73,8 +84,8 @@ function getRules(config: Config): Config["rules"] {
   }
 
   if (config.build?.upload?.rules) {
-    console.warn(
-      `Deprecation notice: The \`build.upload.rules\` config field is no longer used, the rules should be specified via the \`rules\` config field. Delete the \`build.upload\` field from the configuration file, and add this:
+    logger.warn(
+      `Deprecation: The \`build.upload.rules\` config field is no longer used, the rules should be specified via the \`rules\` config field. Delete the \`build.upload\` field from the configuration file, and add this:
 
 ${TOML.stringify({ rules: config.build.upload.rules })}`
     );
@@ -82,45 +93,56 @@ ${TOML.stringify({ rules: config.build.upload.rules })}`
   return rules;
 }
 
-function isLegacyEnv(args: unknown, config: Config): boolean {
-  return (
-    (args as { "legacy-env": boolean | undefined })["legacy-env"] ??
-    config.legacy_env
+async function printWranglerBanner() {
+  // Let's not print this in tests
+  if (typeof jest !== "undefined") {
+    return;
+  }
+
+  const text = ` ⛅️ wrangler ${wranglerVersion} ${await updateCheck()}`;
+
+  logger.log(
+    text +
+      "\n" +
+      (supportsColor.stdout
+        ? chalk.hex("#FF8800")("-".repeat(text.length))
+        : "-".repeat(text.length))
   );
 }
 
+function isLegacyEnv(config: Config): boolean {
+  // We only read from config here, because we've already accounted for
+  // args["legacy-env"] in https://github.com/cloudflare/wrangler2/blob/b24aeb5722370c2e04bce97a84a1fa1e55725d79/packages/wrangler/src/config/validation.ts#L94-L98
+  return config.legacy_env;
+}
+
 function getScriptName(
   args: { name: string | undefined; env: string | undefined },
   config: Config
 ): string | undefined {
-  const shortScriptName = args.name ?? config.name;
-  if (!shortScriptName) {
-    return;
+  if (args.name && isLegacyEnv(config) && args.env) {
+    throw new CommandLineArgsError(
+      "In legacy environment mode you cannot use --name and --env together. If you want to specify a Worker name for a specific environment you can add the following to your wrangler.toml config:" +
+        `
+    [env.${args.env}]
+    name = "${args.name}"
+    `
+    );
   }
 
-  return isLegacyEnv(args, config)
-    ? `${shortScriptName}${args.env ? `-${args.env}` : ""}`
-    : shortScriptName;
+  return args.name ?? config.name;
 }
 
 /**
- * Ensure that a user is logged in, and a valid account_id is available.
+ * Alternative to the getScriptName() because special Legacy cases allowed "name", and "env" together in Wrangler1
  */
-async function requireAuth(
-  config: Config,
-  isInteractive = true
-): Promise<string> {
-  const loggedIn = await loginOrRefreshIfRequired(isInteractive);
-  if (!loggedIn) {
-    // didn't login, let's just quit
-    throw new Error("Did not login, quitting...");
-  }
-  const accountId = config.account_id || (await getAccountId(isInteractive));
-  if (!accountId) {
-    throw new Error("No account id found, quitting...");
-  }
-
-  return accountId;
+function getLegacyScriptName(
+  args: { name: string | undefined; env: string | undefined },
+  config: Config
+) {
+  return args.name && args.env && isLegacyEnv(config)
+    ? `${args.name}-${args.env}`
+    : args.name ?? config.name;
 }
 
 /**
@@ -182,21 +204,18 @@ function demandOneOfOption(...options: string[]) {
 }
 
 class CommandLineArgsError extends Error {}
-class DeprecationError extends Error {
-  constructor(message: string) {
-    super(`DEPRECATION WARNING:\n${message}`);
-  }
-}
 
 export async function main(argv: string[]): Promise<void> {
   const wrangler = makeCLI(argv)
+    .strict()
     // We handle errors ourselves in a try-catch around `yargs.parse`.
     // If you want the "help info" to be displayed then throw an instance of `CommandLineArgsError`.
     // Otherwise we just log the error that was thrown without any "help info".
     .showHelpOnFail(false)
     .fail((msg, error) => {
-      if (!error) {
-        // If there is only a `msg` then this came from yargs own validation, so wrap in a `CommandLineArgsError`.
+      if (!error || error.name === "YError") {
+        // If there is no error or the error is a "YError", then this came from yargs own validation
+        // Wrap it in a `CommandLineArgsError` so that we can handle it appropriately further up.
         error = new CommandLineArgsError(msg);
       }
       throw error;
@@ -246,14 +265,19 @@ export async function main(argv: string[]): Promise<void> {
           default: "worker",
         })
         .positional("template", {
-          describe: "a link to a GitHub template",
+          describe: "The URL of a GitHub template",
           default: "https://github.com/cloudflare/worker-template",
         });
     },
-    () => {
+    (generateArgs) => {
       // "👯 [DEPRECATED]. Scaffold a Cloudflare Workers project from a public GitHub repository.",
       throw new DeprecationError(
-        "`wrangler generate` has been deprecated, please refer to https://github.com/cloudflare/wrangler2/blob/main/docs/deprecations.md#generate for alternatives"
+        "`wrangler generate` has been deprecated.\n" +
+          "Try running `wrangler init` to generate a basic Worker, or cloning the template repository instead:\n\n" +
+          "```\n" +
+          `git clone ${generateArgs.template}\n` +
+          "```\n\n" +
+          "Please refer to https://developers.cloudflare.com/workers/wrangler/deprecations/#generate for more information."
       );
     }
   );
@@ -268,6 +292,18 @@ export async function main(argv: string[]): Promise<void> {
           describe: "The name of your worker",
           type: "string",
         })
+        .option("type", {
+          describe: "The type of worker to create",
+          type: "string",
+          choices: ["rust", "javascript", "webpack"],
+          hidden: true,
+          deprecated: true,
+        })
+        .option("site", {
+          hidden: true,
+          type: "boolean",
+          deprecated: true,
+        })
         .option("yes", {
           describe: 'Answer "yes" to any prompts for new projects',
           type: "boolean",
@@ -275,7 +311,8 @@ export async function main(argv: string[]): Promise<void> {
         });
     },
     async (args) => {
-      if ("type" in args) {
+      await printWranglerBanner();
+      if (args.type) {
         let message = "The --type option is no longer supported.";
         if (args.type === "webpack") {
           message +=
@@ -285,9 +322,30 @@ export async function main(argv: string[]): Promise<void> {
         throw new CommandLineArgsError(message);
       }
 
-      // TODO: make sure args.name is a valid identifier for a worker name
+      const creationDirectory = path.resolve(process.cwd(), args.name ?? "");
+
+      if (args.site) {
+        const gitDirectory =
+          creationDirectory !== process.cwd()
+            ? path.basename(creationDirectory)
+            : "my-site";
+        const message =
+          "The --site option is no longer supported.\n" +
+          "If you wish to create a brand new Worker Sites project then clone the `worker-sites-template` starter repository:\n\n" +
+          "```\n" +
+          `git clone --depth=1 --branch=wrangler2 https://github.com/cloudflare/worker-sites-template ${gitDirectory}\n` +
+          `cd ${gitDirectory}\n` +
+          "```\n\n" +
+          "Find out more about how to create and maintain Sites projects at https://developers.cloudflare.com/workers/platform/sites.\n" +
+          "Have you considered using Cloudflare Pages instead? See https://pages.cloudflare.com/.";
+        throw new CommandLineArgsError(message);
+      }
 
-      const creationDirectory = path.join(process.cwd(), args.name ?? "");
+      // TODO: make sure args.name is a valid identifier for a worker name
+      const workerName = path
+        .basename(creationDirectory)
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9\-_]/gm, "-");
 
       const packageManager = await getPackageManager(creationDirectory);
 
@@ -299,10 +357,14 @@ export async function main(argv: string[]): Promise<void> {
         "./wrangler.toml"
       );
       let justCreatedWranglerToml = false;
-      const workerName =
-        args.name || path.basename(path.resolve(process.cwd()));
+
       if (fs.existsSync(wranglerTomlDestination)) {
-        console.warn(`${wranglerTomlDestination} file already exists!`);
+        logger.warn(
+          `${path.relative(
+            process.cwd(),
+            wranglerTomlDestination
+          )} already exists!`
+        );
         const shouldContinue = await confirm(
           "Do you want to continue initializing this project?"
         );
@@ -312,6 +374,7 @@ export async function main(argv: string[]): Promise<void> {
       } else {
         await mkdir(creationDirectory, { recursive: true });
         const compatibilityDate = new Date().toISOString().substring(0, 10);
+
         try {
           await writeFile(
             wranglerTomlDestination,
@@ -320,18 +383,56 @@ export async function main(argv: string[]): Promise<void> {
               compatibility_date: compatibilityDate,
             }) + "\n"
           );
-          console.log(`✨ Successfully created wrangler.toml`);
+
+          logger.log(
+            `✨ Created ${path.relative(
+              process.cwd(),
+              wranglerTomlDestination
+            )}`
+          );
           justCreatedWranglerToml = true;
         } catch (err) {
           throw new Error(
-            `Failed to create wrangler.toml.\n${(err as Error).message ?? err}`
+            `Failed to create ${path.relative(
+              process.cwd(),
+              wranglerTomlDestination
+            )}.\n${(err as Error).message ?? err}`
           );
         }
       }
 
-      let pathToPackageJson = await findUp("package.json");
-      let shouldCreatePackageJson = false;
       const yesFlag = args.yes ?? false;
+
+      const isInsideGitProject = Boolean(
+        await findUp(".git", { cwd: creationDirectory, type: "directory" })
+      );
+      const isGitInstalled = (await execa("git", ["--version"])).exitCode === 0;
+      if (!isInsideGitProject && isGitInstalled) {
+        const shouldInitGit =
+          yesFlag ||
+          (await confirm("Would you like to use git to manage this Worker?"));
+        if (shouldInitGit) {
+          await execa("git", ["init"], { cwd: creationDirectory });
+          await writeFile(
+            path.join(creationDirectory, ".gitignore"),
+            readFileSync(path.join(__dirname, "../templates/gitignore"))
+          );
+          logger.log(
+            args.name && args.name !== "."
+              ? `✨ Initialized git repository at ${path.relative(
+                  process.cwd(),
+                  creationDirectory
+                )}`
+              : `✨ Initialized git repository`
+          );
+        }
+      }
+
+      let pathToPackageJson = await findUp("package.json", {
+        cwd: creationDirectory,
+      });
+      let shouldCreatePackageJson = false;
+
       if (!pathToPackageJson) {
         // If no package.json exists, ask to create one
         shouldCreatePackageJson =
@@ -356,9 +457,12 @@ export async function main(argv: string[]): Promise<void> {
               "  "
             ) + "\n"
           );
+
           await packageManager.install();
-          console.log(`✨ Created package.json`);
           pathToPackageJson = path.join(creationDirectory, "package.json");
+          logger.log(
+            `✨ Created ${path.relative(process.cwd(), pathToPackageJson)}`
+          );
         } else {
           return;
         }
@@ -378,17 +482,22 @@ export async function main(argv: string[]): Promise<void> {
           const shouldInstall =
             yesFlag ||
             (await confirm(
-              "Would you like to install wrangler into your package.json?"
+              `Would you like to install wrangler into ${path.relative(
+                process.cwd(),
+                pathToPackageJson
+              )}?`
             ));
           if (shouldInstall) {
             await packageManager.addDevDeps(`wrangler@${wranglerVersion}`);
-            console.log(`✨ Installed wrangler`);
+            logger.log(`✨ Installed wrangler`);
           }
         }
       }
 
       let isTypescriptProject = false;
-      let pathToTSConfig = await findUp("tsconfig.json");
+      let pathToTSConfig = await findUp("tsconfig.json", {
+        cwd: creationDirectory,
+      });
       if (!pathToTSConfig) {
         // If there's no tsconfig, offer to create one
         // and install @cloudflare/workers-types
@@ -402,11 +511,13 @@ export async function main(argv: string[]): Promise<void> {
             "@cloudflare/workers-types",
             "typescript"
           );
-
-          console.log(
-            `✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies`
-          );
           pathToTSConfig = path.join(creationDirectory, "tsconfig.json");
+          logger.log(
+            `✨ Created ${path.relative(
+              process.cwd(),
+              pathToTSConfig
+            )}, installed @cloudflare/workers-types into devDependencies`
+          );
         }
       } else {
         isTypescriptProject = true;
@@ -431,8 +542,11 @@ export async function main(argv: string[]): Promise<void> {
             // it could be complicated in existing projects
             // and we don't want to break them. Instead, we simply
             // tell the user that they need to update their tsconfig.json
-            console.log(
-              `✨ Installed @cloudflare/workers-types.\nPlease add "@cloudflare/workers-types" to compilerOptions.types in your tsconfig.json`
+            logger.log(
+              `✨ Installed @cloudflare/workers-types.\nPlease add "@cloudflare/workers-types" to compilerOptions.types in ${path.relative(
+                process.cwd(),
+                pathToTSConfig
+              )}`
             );
           }
         }
@@ -455,7 +569,7 @@ export async function main(argv: string[]): Promise<void> {
       ) {
         if (isCreatingWranglerToml) {
           // rewrite wrangler.toml with main = "path/to/script"
-          const parsedWranglerToml = TOML.parse(
+          const parsedWranglerToml = parseTOML(
             readFileSync(wranglerTomlDestination)
           );
           fs.writeFileSync(
@@ -490,21 +604,21 @@ export async function main(argv: string[]): Promise<void> {
               2
             ) + "\n"
           );
-          console.log(
+          logger.log(
             `\nTo start developing your Worker, run \`${
               isNamedWorker ? `cd ${args.name} && ` : ""
             }npm start\``
           );
-          console.log(
+          logger.log(
             `To publish your Worker to the Internet, run \`npm run publish\``
           );
         } else {
-          console.log(
+          logger.log(
             `\nTo start developing your Worker, run \`npx wrangler dev\`${
               isCreatingWranglerToml ? "" : ` ${scriptPath}`
             }`
           );
-          console.log(
+          logger.log(
             `To publish your Worker to the Internet, run \`npx wrangler publish\`${
               isCreatingWranglerToml ? "" : ` ${scriptPath}`
             }`
@@ -514,12 +628,13 @@ export async function main(argv: string[]): Promise<void> {
 
       if (isTypescriptProject) {
         if (!fs.existsSync(path.join(creationDirectory, "./src/index.ts"))) {
-          let shouldCreateSource = false;
-
-          shouldCreateSource =
+          const shouldCreateSource =
             yesFlag ||
             (await confirm(
-              `Would you like to create a Worker at src/index.ts?`
+              `Would you like to create a Worker at ${path.relative(
+                process.cwd(),
+                path.join(creationDirectory, "./src/index.ts")
+              )}?`
             ));
 
           if (shouldCreateSource) {
@@ -531,7 +646,12 @@ export async function main(argv: string[]): Promise<void> {
               readFileSync(path.join(__dirname, "../templates/new-worker.ts"))
             );
 
-            console.log(`✨ Created src/index.ts`);
+            logger.log(
+              `✨ Created ${path.relative(
+                process.cwd(),
+                path.join(creationDirectory, "./src/index.ts")
+              )}`
+            );
 
             await writePackageJsonScriptsAndUpdateWranglerToml(
               shouldWritePackageJsonScripts,
@@ -542,20 +662,31 @@ export async function main(argv: string[]): Promise<void> {
           }
         }
       } else {
-        if (!fs.existsSync("./src/index.js")) {
-          const shouldCreateSource = await confirm(
-            `Would you like to create a Worker at src/index.js?`
-          );
+        if (!fs.existsSync(path.join(creationDirectory, "./src/index.js"))) {
+          const shouldCreateSource =
+            yesFlag ||
+            (await confirm(
+              `Would you like to create a Worker at ${path.relative(
+                process.cwd(),
+                path.join(creationDirectory, "./src/index.js")
+              )}?`
+            ));
+
           if (shouldCreateSource) {
             await mkdir(path.join(creationDirectory, "./src"), {
               recursive: true,
             });
             await writeFile(
-              path.join(path.join(creationDirectory, "./src/index.js")),
+              path.join(creationDirectory, "./src/index.js"),
               readFileSync(path.join(__dirname, "../templates/new-worker.js"))
             );
 
-            console.log(`✨ Created src/index.js`);
+            logger.log(
+              `✨ Created ${path.relative(
+                process.cwd(),
+                path.join(creationDirectory, "./src/index.js")
+              )}`
+            );
 
             await writePackageJsonScriptsAndUpdateWranglerToml(
               shouldWritePackageJsonScripts,
@@ -586,76 +717,6 @@ export async function main(argv: string[]): Promise<void> {
     }
   );
 
-  // login
-  wrangler.command(
-    // this needs scopes as an option?
-    "login",
-    false, // we don't need to show this in the menu
-    // "🔓 Login to Cloudflare",
-    (yargs) => {
-      // TODO: This needs some copy editing
-      // I mean, this entire app does, but this too.
-      return yargs
-        .option("scopes-list", {
-          describe: "List all the available OAuth scopes with descriptions",
-        })
-        .option("scopes", {
-          describe: "Pick the set of applicable OAuth scopes when logging in",
-          array: true,
-          type: "string",
-        });
-
-      // TODO: scopes
-    },
-    async (args) => {
-      if (args["scopes-list"]) {
-        listScopes();
-        return;
-      }
-      if (args.scopes) {
-        if (args.scopes.length === 0) {
-          // don't allow no scopes to be passed, that would be weird
-          listScopes();
-          return;
-        }
-        if (!validateScopeKeys(args.scopes)) {
-          throw new CommandLineArgsError(
-            `One of ${args.scopes} is not a valid authentication scope. Run "wrangler login --list-scopes" to see the valid scopes.`
-          );
-        }
-        await login({ scopes: args.scopes });
-        return;
-      }
-      await login();
-
-      // TODO: would be nice if it optionally saved login
-      // credentials inside node_modules/.cache or something
-      // this way you could have multiple users on a single machine
-    }
-  );
-
-  // logout
-  wrangler.command(
-    // this needs scopes as an option?
-    "logout",
-    false, // we don't need to show this in the menu
-    // "🚪 Logout from Cloudflare",
-    () => {},
-    async () => {
-      await logout();
-    }
-  );
-
-  // whoami
-  wrangler.command(
-    "whoami",
-    "🕵️  Retrieve your user info and test your auth config",
-    () => {},
-    async () => {
-      await whoami();
-    }
-  );
-
   // config
   wrangler.command(
     "config",
@@ -664,7 +725,7 @@ export async function main(argv: string[]): Promise<void> {
     () => {
       // "🕵️  Authenticate Wrangler with a Cloudflare API Token",
       throw new DeprecationError(
-        "`wrangler config` has been deprecated, please refer to TODO://some/path for alternatives"
+        "`wrangler config` has been deprecated, please refer to https://github.com/cloudflare/wrangler2/blob/main/docs/deprecations.md#config for alternatives"
       );
     }
   );
@@ -682,23 +743,30 @@ export async function main(argv: string[]): Promise<void> {
         .option("name", {
           describe: "Name of the worker",
           type: "string",
+          requiresArg: true,
         })
         .option("format", {
           choices: ["modules", "service-worker"] as const,
           describe: "Choose an entry type",
+          deprecated: true,
         })
         .option("env", {
           describe: "Perform on a specific environment",
           type: "string",
+          requiresArg: true,
+          alias: "e",
         })
         .option("compatibility-date", {
           describe: "Date to use for compatibility checks",
           type: "string",
+          requiresArg: true,
         })
         .option("compatibility-flags", {
           describe: "Flags to use for compatibility checks",
-          type: "array",
           alias: "compatibility-flag",
+          type: "string",
+          requiresArg: true,
+          array: true,
         })
         .option("latest", {
           describe: "Use the latest version of the worker runtime",
@@ -706,9 +774,9 @@ export async function main(argv: string[]): Promise<void> {
           default: true,
         })
         .option("ip", {
-          describe: "IP address to listen on",
+          describe: "IP address to listen on, defaults to `localhost`",
           type: "string",
-          default: "127.0.0.1",
+          requiresArg: true,
         })
         .option("port", {
           describe: "Port to listen on",
@@ -721,10 +789,13 @@ export async function main(argv: string[]): Promise<void> {
         .option("routes", {
           describe: "Routes to upload",
           alias: "route",
-          type: "array",
+          type: "string",
+          requiresArg: true,
+          array: true,
         })
         .option("host", {
           type: "string",
+          requiresArg: true,
           describe:
             "Host to forward requests to, defaults to the zone of project",
         })
@@ -735,21 +806,25 @@ export async function main(argv: string[]): Promise<void> {
         .option("experimental-public", {
           describe: "Static assets to be served",
           type: "string",
+          requiresArg: true,
         })
         .option("site", {
           describe: "Root folder of static assets for Workers Sites",
           type: "string",
+          requiresArg: true,
         })
         .option("site-include", {
           describe:
             "Array of .gitignore-style patterns that match file or directory names from the sites directory. Only matched items will be uploaded.",
           type: "string",
+          requiresArg: true,
           array: true,
         })
         .option("site-exclude", {
           describe:
             "Array of .gitignore-style patterns that match file or directory names from the sites directory. Matched items will not be uploaded.",
           type: "string",
+          requiresArg: true,
           array: true,
         })
         .option("upstream-protocol", {
@@ -760,10 +835,17 @@ export async function main(argv: string[]): Promise<void> {
         .option("jsx-factory", {
           describe: "The function that is called for each JSX element",
           type: "string",
+          requiresArg: true,
         })
         .option("jsx-fragment", {
           describe: "The function that is called for each JSX fragment",
           type: "string",
+          requiresArg: true,
+        })
+        .option("tsconfig", {
+          describe: "Path to a custom tsconfig.json file",
+          type: "string",
+          requiresArg: true,
         })
         .option("local", {
           alias: "l",
@@ -771,35 +853,54 @@ export async function main(argv: string[]): Promise<void> {
           type: "boolean",
           default: false, // I bet this will a point of contention. We'll revisit it.
         })
+        .option("minify", {
+          describe: "Minify the script",
+          type: "boolean",
+        })
+        .option("node-compat", {
+          describe: "Enable node.js compatibility",
+          type: "boolean",
+        })
         .option("experimental-enable-local-persistence", {
           describe: "Enable persistence for this session (only for local mode)",
           type: "boolean",
+        })
+        .option("inspect", {
+          describe: "Enable dev tools",
+          type: "boolean",
+          deprecated: true,
         });
     },
     async (args) => {
-      const config = readConfig(
+      await printWranglerBanner();
+      const configPath =
         (args.config as ConfigPath) ||
-          (args.script && findWranglerToml(path.dirname(args.script)))
-      );
+        (args.script && findWranglerToml(path.dirname(args.script)));
+      const config = readConfig(configPath, args);
       const entry = await getEntry(args, config, "dev");
 
+      if (args.inspect) {
+        logger.warn(
+          "Passing --inspect is unnecessary, now you can always connect to devtools."
+        );
+      }
+
       if (args["experimental-public"]) {
-        console.warn(
-          "🚨  The --experimental-public field is experimental and will change in the future."
+        logger.warn(
+          "The --experimental-public field is experimental and will change in the future."
         );
       }
 
       if (args.public) {
         throw new Error(
-          "🚨  The --public field has been renamed to --experimental-public, and will change behaviour in the future."
+          "The --public field has been renamed to --experimental-public, and will change behaviour in the future."
         );
       }
 
       const upstreamProtocol =
-        (args["upstream-protocol"] as "http" | "https") ||
-        config.dev.upstream_protocol;
+        args["upstream-protocol"] || config.dev.upstream_protocol;
       if (upstreamProtocol === "http") {
-        console.warn(
+        logger.warn(
           "Setting upstream-protocol to http is not currently implemented.\n" +
             "If this is required in your project, please add your use case to the following issue:\n" +
             "https://github.com/cloudflare/wrangler2/issues/583."
@@ -836,16 +937,6 @@ export async function main(argv: string[]): Promise<void> {
         return zones[0]?.id;
       }
 
-      const environments = config.env ?? {};
-      const envRootObj = args.env ? environments[args.env] || {} : config;
-
-      const hostLike =
-        args.host ||
-        config.dev.host ||
-        (args.routes && args.routes[0]) ||
-        envRootObj.route ||
-        (envRootObj.routes && envRootObj.routes[0]);
-
       // When we're given a host (in one of the above ways), we do 2 things:
       // - We try to extract a host from it
       // - We try to get a zone id from the host
@@ -856,27 +947,57 @@ export async function main(argv: string[]): Promise<void> {
       // get a zone id for it, by lopping off subdomains until we get a hit
       // from the API. That's it!
 
-      const host = typeof hostLike === "string" ? getHost(hostLike) : undefined;
+      let zone: { host: string; id: string } | undefined;
+
+      if (!args.local) {
+        const hostLike =
+          args.host ||
+          config.dev.host ||
+          (args.routes && args.routes[0]) ||
+          config.route ||
+          (config.routes && config.routes[0]);
+
+        let zoneId: string | undefined =
+          typeof hostLike === "object" && "zone_id" in hostLike
+            ? hostLike.zone_id
+            : undefined;
+
+        const host =
+          typeof hostLike === "string"
+            ? getHost(hostLike)
+            : typeof hostLike === "object"
+            ? "zone_name" in hostLike
+              ? getHost(hostLike.zone_name)
+              : getHost(hostLike.pattern)
+            : undefined;
+
+        const hostPieces =
+          typeof host === "string" ? host.split(".") : undefined;
+
+        while (!zoneId && hostPieces && hostPieces.length > 1) {
+          zoneId = await getZoneId(hostPieces.join("."));
+          hostPieces.shift();
+        }
 
-      let zoneId: string | undefined;
-      const hostPieces = typeof host === "string" ? host.split(".") : undefined;
+        if (host && !zoneId) {
+          throw new Error(`Could not find zone for ${hostLike}`);
+        }
 
-      while (hostPieces && hostPieces.length > 1) {
-        zoneId = await getZoneId(hostPieces.join("."));
-        if (zoneId) break;
-        hostPieces.shift();
-      }
-      if (host && !zoneId) {
-        throw new Error(`Could not find zone for ${hostLike}`);
+        zone =
+          typeof zoneId === "string" && typeof host === "string"
+            ? {
+                host,
+                id: zoneId,
+              }
+            : undefined;
       }
 
-      const zone =
-        typeof zoneId === "string" && typeof host === "string"
-          ? {
-              host,
-              id: zoneId,
-            }
-          : undefined;
+      const nodeCompat = args.nodeCompat ?? config.node_compat;
+      if (nodeCompat) {
+        logger.warn(
+          "Enabling node.js compatibility mode for builtins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
+        );
+      }
 
       const { waitUntilExit } = render(
         <Dev
@@ -885,18 +1006,16 @@ export async function main(argv: string[]): Promise<void> {
           env={args.env}
           zone={zone}
           rules={getRules(config)}
-          legacyEnv={isLegacyEnv(args, config)}
-          buildCommand={config.build || {}}
+          legacyEnv={isLegacyEnv(config)}
+          minify={args.minify ?? config.minify}
+          nodeCompat={nodeCompat}
+          build={config.build || {}}
           initialMode={args.local ? "local" : "remote"}
-          jsxFactory={args["jsx-factory"] || envRootObj?.jsx_factory}
-          jsxFragment={args["jsx-fragment"] || envRootObj?.jsx_fragment}
+          jsxFactory={args["jsx-factory"] || config.jsx_factory}
+          jsxFragment={args["jsx-fragment"] || config.jsx_fragment}
+          tsconfig={args.tsconfig ?? config.tsconfig}
           upstreamProtocol={upstreamProtocol}
-          localProtocol={
-            // The typings are not quite clever enough to handle element accesses, only property accesses,
-            // so we need to cast here.
-            (args["local-protocol"] as "http" | "https") ||
-            config.dev.local_protocol
-          }
+          localProtocol={args["local-protocol"] || config.dev.local_protocol}
           enableLocalPersistence={
             args["experimental-enable-local-persistence"] || false
           }
@@ -910,22 +1029,21 @@ export async function main(argv: string[]): Promise<void> {
           port={
             args.port || config.dev?.port || (await getPort({ port: 8787 }))
           }
+          ip={args.ip || config.dev.ip}
           inspectorPort={
             args["inspector-port"] ?? (await getPort({ port: 9229 }))
           }
           public={args["experimental-public"]}
-          compatibilityDate={
-            args["compatibility-date"] ||
-            config.compatibility_date ||
-            new Date().toISOString().substring(0, 10)
-          }
+          compatibilityDate={getDevCompatibilityDate(
+            config,
+            args["compatibility-date"]
+          )}
           compatibilityFlags={
-            (args["compatibility-flags"] as string[]) ||
-            config.compatibility_flags
+            args["compatibility-flags"] || config.compatibility_flags
           }
-          usageModel={envRootObj.usage_model}
+          usageModel={config.usage_model}
           bindings={{
-            kv_namespaces: envRootObj.kv_namespaces?.map(
+            kv_namespaces: config.kv_namespaces?.map(
               ({ binding, preview_id, id: _id }) => {
                 // In `dev`, we make folks use a separate kv namespace called
                 // `preview_id` instead of `id` so that they don't
@@ -946,13 +1064,29 @@ export async function main(argv: string[]): Promise<void> {
                 };
               }
             ),
-            vars: envRootObj.vars,
+            vars: getVarsForDev(config),
             wasm_modules: config.wasm_modules,
             text_blobs: config.text_blobs,
-            durable_objects: envRootObj.durable_objects,
-            r2_buckets: envRootObj.r2_buckets,
-            unsafe: envRootObj.unsafe?.bindings,
+            data_blobs: config.data_blobs,
+            durable_objects: config.durable_objects,
+            r2_buckets: config.r2_buckets?.map(
+              ({ binding, preview_bucket_name, bucket_name: _bucket_name }) => {
+                // same idea as kv namespace preview id,
+                // same copy-on-write TODO
+                if (!preview_bucket_name) {
+                  throw new Error(
+                    `In development, you should use a separate r2 bucket than the one you'd use in production. Please create a new r2 bucket with "wrangler r2 bucket create <name>" and add its name as preview_bucket_name to the r2_buckets "${binding}" in your wrangler.toml`
+                  );
+                }
+                return {
+                  binding,
+                  bucket_name: preview_bucket_name,
+                };
+              }
+            ),
+            unsafe: config.unsafe?.bindings,
           }}
+          crons={config.triggers.crons}
         />
       );
       await waitUntilExit();
@@ -967,28 +1101,41 @@ export async function main(argv: string[]): Promise<void> {
       return yargs
         .option("env", {
           type: "string",
+          requiresArg: true,
           describe: "Perform on a specific environment",
+          alias: "e",
         })
         .positional("script", {
           describe: "The path to an entry point for your worker",
           type: "string",
+          requiresArg: true,
         })
         .option("name", {
           describe: "Name of the worker",
           type: "string",
+          requiresArg: true,
+        })
+        .option("outdir", {
+          describe: "Output directory for the bundled worker",
+          type: "string",
+          requiresArg: true,
         })
         .option("format", {
           choices: ["modules", "service-worker"] as const,
           describe: "Choose an entry type",
+          deprecated: true,
         })
         .option("compatibility-date", {
           describe: "Date to use for compatibility checks",
           type: "string",
+          requiresArg: true,
         })
         .option("compatibility-flags", {
           describe: "Flags to use for compatibility checks",
-          type: "array",
           alias: "compatibility-flag",
+          type: "string",
+          requiresArg: true,
+          array: true,
         })
         .option("latest", {
           describe: "Use the latest version of the worker runtime",
@@ -998,63 +1145,91 @@ export async function main(argv: string[]): Promise<void> {
         .option("experimental-public", {
           describe: "Static assets to be served",
           type: "string",
+          requiresArg: true,
         })
         .option("site", {
           describe: "Root folder of static assets for Workers Sites",
           type: "string",
+          requiresArg: true,
         })
         .option("site-include", {
           describe:
             "Array of .gitignore-style patterns that match file or directory names from the sites directory. Only matched items will be uploaded.",
           type: "string",
+          requiresArg: true,
           array: true,
         })
         .option("site-exclude", {
           describe:
             "Array of .gitignore-style patterns that match file or directory names from the sites directory. Matched items will not be uploaded.",
           type: "string",
+          requiresArg: true,
           array: true,
         })
         .option("triggers", {
           describe: "cron schedules to attach",
           alias: ["schedule", "schedules"],
-          type: "array",
+          type: "string",
+          requiresArg: true,
+          array: true,
         })
         .option("routes", {
           describe: "Routes to upload",
           alias: "route",
-          type: "array",
+          type: "string",
+          requiresArg: true,
+          array: true,
         })
         .option("jsx-factory", {
           describe: "The function that is called for each JSX element",
           type: "string",
+          requiresArg: true,
         })
         .option("jsx-fragment", {
           describe: "The function that is called for each JSX fragment",
           type: "string",
+          requiresArg: true,
+        })
+        .option("tsconfig", {
+          describe: "Path to a custom tsconfig.json file",
+          type: "string",
+          requiresArg: true,
+        })
+        .option("minify", {
+          describe: "Minify the script",
+          type: "boolean",
+        })
+        .option("node-compat", {
+          describe: "Enable node.js compatibility",
+          type: "boolean",
+        })
+        .option("dry-run", {
+          describe: "Don't actually publish",
+          type: "boolean",
         });
     },
     async (args) => {
+      await printWranglerBanner();
       if (args["experimental-public"]) {
-        console.warn(
-          "🚨  The --experimental-public field is experimental and will change in the future."
+        logger.warn(
+          "The --experimental-public field is experimental and will change in the future."
         );
       }
       if (args.public) {
         throw new Error(
-          "🚨  The --public field has been renamed to --experimental-public, and will change behaviour in the future."
+          "The --public field has been renamed to --experimental-public, and will change behaviour in the future."
         );
       }
 
-      const config = readConfig(
+      const configPath =
         (args.config as ConfigPath) ||
-          (args.script && findWranglerToml(path.dirname(args.script)))
-      );
+        (args.script && findWranglerToml(path.dirname(args.script)));
+      const config = readConfig(configPath, args);
       const entry = await getEntry(args, config, "publish");
 
       if (args.latest) {
-        console.warn(
-          "⚠️  Using the latest version of the Workers runtime. To silence this warning, please choose a specific version of the runtime with --compatibility-date, or add a compatibility_date to your wrangler.toml.\n"
+        logger.warn(
+          "Using the latest version of the Workers runtime. To silence this warning, please choose a specific version of the runtime with --compatibility-date, or add a compatibility_date to your wrangler.toml.\n"
         );
       }
 
@@ -1076,14 +1251,19 @@ export async function main(argv: string[]): Promise<void> {
         compatibilityDate: args.latest
           ? new Date().toISOString().substring(0, 10)
           : args["compatibility-date"],
-        compatibilityFlags: args["compatibility-flags"] as string[],
+        compatibilityFlags: args["compatibility-flags"],
         triggers: args.triggers,
         jsxFactory: args["jsx-factory"],
         jsxFragment: args["jsx-fragment"],
+        tsconfig: args.tsconfig,
         routes: args.routes,
         assetPaths,
-        legacyEnv: isLegacyEnv(args, config),
+        legacyEnv: isLegacyEnv(config),
+        minify: args.minify,
+        nodeCompat: args.nodeCompat,
         experimentalPublic: args["experimental-public"] !== undefined,
+        outDir: args.outdir,
+        dryRun: args.dryRun,
       });
     }
   );
@@ -1093,63 +1273,69 @@ export async function main(argv: string[]): Promise<void> {
     "tail [name]",
     "🦚 Starts a log tailing session for a published Worker.",
     (yargs) => {
-      return (
-        yargs
-          .positional("name", {
-            describe: "Name of the worker",
-            type: "string",
-          })
-          // TODO: auto-detect if this should be json or pretty based on atty
-          .option("format", {
-            default: "json",
-            choices: ["json", "pretty"],
-            describe: "The format of log entries",
-          })
-          .option("status", {
-            choices: ["ok", "error", "canceled"],
-            describe: "Filter by invocation status",
-            array: true,
-          })
-          .option("header", {
-            type: "string",
-            describe: "Filter by HTTP header",
-          })
-          .option("method", {
-            type: "string",
-            describe: "Filter by HTTP method",
-            array: true,
-          })
-          .option("sampling-rate", {
-            type: "number",
-            describe: "Adds a percentage of requests to log sampling rate",
-          })
-          .option("search", {
-            type: "string",
-            describe: "Filter by a text match in console.log messages",
-          })
-          .option("ip", {
-            type: "string",
-            describe:
-              'Filter by the IP address the request originates from. Use "self" to filter for your own IP',
-            array: true,
-          })
-          .option("env", {
-            type: "string",
-            describe: "Perform on a specific environment",
-          })
-          .option("debug", {
-            type: "boolean",
-            hidden: true,
-            default: false,
-            describe:
-              "If a log would have been filtered out, send it through anyway alongside the filter which would have blocked it.",
-          })
-      );
+      return yargs
+        .positional("name", {
+          describe: "Name of the worker",
+          type: "string",
+        })
+        .option("format", {
+          default: process.stdout.isTTY ? "pretty" : "json",
+          choices: ["json", "pretty"],
+          describe: "The format of log entries",
+        })
+        .option("status", {
+          choices: ["ok", "error", "canceled"],
+          describe: "Filter by invocation status",
+          array: true,
+        })
+        .option("header", {
+          type: "string",
+          requiresArg: true,
+          describe: "Filter by HTTP header",
+        })
+        .option("method", {
+          type: "string",
+          requiresArg: true,
+          describe: "Filter by HTTP method",
+          array: true,
+        })
+        .option("sampling-rate", {
+          type: "number",
+          describe: "Adds a percentage of requests to log sampling rate",
+        })
+        .option("search", {
+          type: "string",
+          requiresArg: true,
+          describe: "Filter by a text match in console.log messages",
+        })
+        .option("ip", {
+          type: "string",
+          requiresArg: true,
+          describe:
+            'Filter by the IP address the request originates from. Use "self" to filter for your own IP',
+          array: true,
+        })
+        .option("env", {
+          type: "string",
+          requiresArg: true,
+          describe: "Perform on a specific environment",
+          alias: "e",
+        })
+        .option("debug", {
+          type: "boolean",
+          hidden: true,
+          default: false,
+          describe:
+            "If a log would have been filtered out, send it through anyway alongside the filter which would have blocked it.",
+        });
     },
     async (args) => {
-      const config = readConfig(args.config as ConfigPath);
+      if (args.format === "pretty") {
+        await printWranglerBanner();
+      }
+      const config = readConfig(args.config as ConfigPath, args);
 
-      const scriptName = getScriptName(args, config);
+      const scriptName = getLegacyScriptName(args, config);
 
       if (!scriptName) {
         throw new Error("Missing script name");
@@ -1158,7 +1344,7 @@ export async function main(argv: string[]): Promise<void> {
       const accountId = await requireAuth(config);
 
       const cliFilters: TailCLIFilters = {
-        status: args.status as ("ok" | "error" | "canceled")[],
+        status: args.status as ("ok" | "error" | "canceled")[] | undefined,
         header: args.header,
         method: args.method,
         samplingRate: args["sampling-rate"],
@@ -1175,16 +1361,18 @@ export async function main(argv: string[]): Promise<void> {
         accountId,
         scriptName,
         filters,
-        !isLegacyEnv(args, config) ? args.env : undefined
+        !isLegacyEnv(config) ? args.env : undefined
       );
 
       const scriptDisplayName = `${scriptName}${
-        args.env && !isLegacyEnv(args, config) ? ` (${args.env})` : ""
+        args.env && !isLegacyEnv(config) ? ` (${args.env})` : ""
       }`;
 
-      console.log(
-        `successfully created tail, expires at ${expiration.toLocaleString()}`
-      );
+      if (args.format === "pretty") {
+        logger.log(
+          `Successfully created tail, expires at ${expiration.toLocaleString()}`
+        );
+      }
 
       onExit(async () => {
         tail.terminate();
@@ -1211,7 +1399,9 @@ export async function main(argv: string[]): Promise<void> {
         }
       }
 
-      console.log(`Connected to ${scriptDisplayName}, waiting for logs...`);
+      if (args.format === "pretty") {
+        logger.log(`Connected to ${scriptDisplayName}, waiting for logs...`);
+      }
 
       tail.on("close", async () => {
         tail.terminate();
@@ -1236,6 +1426,7 @@ export async function main(argv: string[]): Promise<void> {
         })
         .option("env", {
           type: "string",
+          requiresArg: true,
           describe: "Perform on a specific environment",
         })
         .option("watch", {
@@ -1253,21 +1444,18 @@ export async function main(argv: string[]): Promise<void> {
       }
 
       // Delegate to `wrangler dev`
-      console.warn(
+      logger.warn(
         "***************************************************\n" +
           "The `wrangler preview` command has been deprecated.\n" +
           "Attempting to run `wrangler dev` instead.\n" +
           "***************************************************\n"
       );
 
-      const config = readConfig(args.config as ConfigPath);
+      const config = readConfig(args.config as ConfigPath, args);
       const entry = await getEntry({}, config, "dev");
 
       const accountId = await requireAuth(config);
 
-      const environments = config.env ?? {};
-      const envRootObj = args.env ? environments[args.env] || {} : config;
-
       const { waitUntilExit } = render(
         <Dev
           name={config.name}
@@ -1275,29 +1463,27 @@ export async function main(argv: string[]): Promise<void> {
           rules={getRules(config)}
           env={args.env}
           zone={undefined}
-          legacyEnv={isLegacyEnv(args, config)}
-          buildCommand={config.build || {}}
+          legacyEnv={isLegacyEnv(config)}
+          build={config.build || {}}
+          minify={undefined}
+          nodeCompat={config.node_compat}
           initialMode={args.local ? "local" : "remote"}
-          jsxFactory={envRootObj?.jsx_factory}
-          jsxFragment={envRootObj?.jsx_fragment}
+          jsxFactory={config.jsx_factory}
+          jsxFragment={config.jsx_fragment}
+          tsconfig={config.tsconfig}
           upstreamProtocol={config.dev.upstream_protocol}
           localProtocol={config.dev.local_protocol}
           enableLocalPersistence={false}
           accountId={accountId}
           assetPaths={undefined}
           port={config.dev?.port}
+          ip={config.dev.ip}
           public={undefined}
-          compatibilityDate={
-            config.compatibility_date ||
-            new Date().toISOString().substring(0, 10)
-          }
-          compatibilityFlags={
-            (args["compatibility-flags"] as string[]) ||
-            config.compatibility_flags
-          }
+          compatibilityDate={getDevCompatibilityDate(config)}
+          compatibilityFlags={config.compatibility_flags}
           usageModel={config.usage_model}
           bindings={{
-            kv_namespaces: envRootObj.kv_namespaces?.map(
+            kv_namespaces: config.kv_namespaces?.map(
               ({ binding, preview_id, id: _id }) => {
                 // In `dev`, we make folks use a separate kv namespace called
                 // `preview_id` instead of `id` so that they don't
@@ -1318,13 +1504,29 @@ export async function main(argv: string[]): Promise<void> {
                 };
               }
             ),
-            vars: envRootObj.vars,
+            vars: config.vars,
             wasm_modules: config.wasm_modules,
             text_blobs: config.text_blobs,
-            durable_objects: envRootObj.durable_objects,
-            r2_buckets: envRootObj.r2_buckets,
-            unsafe: envRootObj.unsafe?.bindings,
+            data_blobs: config.data_blobs,
+            durable_objects: config.durable_objects,
+            r2_buckets: config.r2_buckets?.map(
+              ({ binding, preview_bucket_name, bucket_name: _bucket_name }) => {
+                // same idea as kv namespace preview id,
+                // same copy-on-write TODO
+                if (!preview_bucket_name) {
+                  throw new Error(
+                    `In development, you should use a separate r2 bucket than the one you'd use in production. Please create a new r2 bucket with "wrangler r2 bucket create <name>" and add its name as preview_bucket_name to the r2_buckets "${binding}" in your wrangler.toml`
+                  );
+                }
+                return {
+                  binding,
+                  bucket_name: preview_bucket_name,
+                };
+              }
+            ),
+            unsafe: config.unsafe?.bindings,
           }}
+          crons={config.triggers.crons}
           inspectorPort={await getPort({ port: 9229 })}
         />
       );
@@ -1346,10 +1548,12 @@ export async function main(argv: string[]): Promise<void> {
             return yargs
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
               })
               .option("zone", {
                 type: "string",
+                requiresArg: true,
                 describe: "Zone id",
               })
               .positional("zone", {
@@ -1371,7 +1575,7 @@ export async function main(argv: string[]): Promise<void> {
           }
         )
         .command(
-          "delete",
+          "delete [id]",
           "Delete a route associated with a zone",
           (yargs) => {
             return yargs
@@ -1381,10 +1585,12 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("zone", {
                 type: "string",
+                requiresArg: true,
                 describe: "zone id",
               })
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
               });
           },
@@ -1417,7 +1623,7 @@ export async function main(argv: string[]): Promise<void> {
     },
     () => {
       throw new DeprecationError(
-        "`wrangler subdomain` has been deprecated, please refer to TODO://some/path for alternatives"
+        "`wrangler subdomain` has been deprecated, please refer to https://github.com/cloudflare/wrangler2/blob/main/docs/deprecations.md#subdomain for alternatives"
       );
     }
   );
@@ -1441,37 +1647,41 @@ export async function main(argv: string[]): Promise<void> {
               .option("name", {
                 describe: "Name of the worker",
                 type: "string",
+                requiresArg: true,
               })
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe:
                   "Binds the secret to the Worker of the specific environment",
+                alias: "e",
               });
           },
           async (args) => {
-            const config = readConfig(args.config as ConfigPath);
+            await printWranglerBanner();
+            const config = readConfig(args.config as ConfigPath, args);
 
-            const scriptName = getScriptName(args, config);
+            const scriptName = getLegacyScriptName(args, config);
             if (!scriptName) {
               throw new Error("Missing script name");
             }
 
-            const isInteractive = process.stdin.isTTY;
-            const accountId = await requireAuth(config, isInteractive);
+            const accountId = await requireAuth(config);
 
+            const isInteractive = process.stdin.isTTY;
             const secretValue = isInteractive
               ? await prompt("Enter a secret value:", "password")
               : await readFromStdin();
 
-            console.log(
+            logger.log(
               `🌀 Creating the secret for script ${scriptName} ${
-                args.env && !isLegacyEnv(args, config) ? `(${args.env})` : ""
+                args.env && !isLegacyEnv(config) ? `(${args.env})` : ""
               }`
             );
 
             async function submitSecret() {
               const url =
-                !args.env || isLegacyEnv(args, config)
+                !args.env || isLegacyEnv(config)
                   ? `/accounts/${accountId}/workers/scripts/${scriptName}/secrets`
                   : `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/secrets`;
 
@@ -1489,7 +1699,7 @@ export async function main(argv: string[]): Promise<void> {
             const createDraftWorker = async () => {
               // TODO: log a warning
               await fetchResult(
-                !args["legacy-env"] && args.env
+                !isLegacyEnv(config) && args.env
                   ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}`
                   : `/accounts/${accountId}/workers/scripts/${scriptName}`,
                 {
@@ -1508,6 +1718,7 @@ export async function main(argv: string[]): Promise<void> {
                       r2_buckets: [],
                       wasm_modules: {},
                       text_blobs: {},
+                      data_blobs: {},
                       unsafe: [],
                     },
                     modules: [],
@@ -1524,7 +1735,7 @@ export async function main(argv: string[]): Promise<void> {
               return (
                 typeof e === "object" &&
                 e !== null &&
-                (e as { code: 10007 }).code === 10007
+                (e as { code: number }).code === 10007
               );
             }
 
@@ -1541,13 +1752,14 @@ export async function main(argv: string[]): Promise<void> {
               }
             }
 
-            console.log(`✨ Success! Uploaded secret ${args.key}`);
+            logger.log(`✨ Success! Uploaded secret ${args.key}`);
           }
         )
         .command(
           "delete <key>",
           "Delete a secret variable from a script",
-          (yargs) => {
+          async (yargs) => {
+            await printWranglerBanner();
             return yargs
               .positional("key", {
                 describe: "The variable name to be accessible in the script",
@@ -1556,17 +1768,20 @@ export async function main(argv: string[]): Promise<void> {
               .option("name", {
                 describe: "Name of the worker",
                 type: "string",
+                requiresArg: true,
               })
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe:
                   "Binds the secret to the Worker of the specific environment",
+                alias: "e",
               });
           },
           async (args) => {
-            const config = readConfig(args.config as ConfigPath);
+            const config = readConfig(args.config as ConfigPath, args);
 
-            const scriptName = getScriptName(args, config);
+            const scriptName = getLegacyScriptName(args, config);
             if (!scriptName) {
               throw new Error("Missing script name");
             }
@@ -1578,23 +1793,23 @@ export async function main(argv: string[]): Promise<void> {
                 `Are you sure you want to permanently delete the variable ${
                   args.key
                 } on the script ${scriptName}${
-                  args.env && !isLegacyEnv(args, config) ? ` (${args.env})` : ""
+                  args.env && !isLegacyEnv(config) ? ` (${args.env})` : ""
                 }?`
               )
             ) {
-              console.log(
+              logger.log(
                 `🌀 Deleting the secret ${args.key} on script ${scriptName}${
-                  args.env && !isLegacyEnv(args, config) ? ` (${args.env})` : ""
+                  args.env && !isLegacyEnv(config) ? ` (${args.env})` : ""
                 }`
               );
 
               const url =
-                !args.env || isLegacyEnv(args, config)
+                !args.env || isLegacyEnv(config)
                   ? `/accounts/${accountId}/workers/scripts/${scriptName}/secrets`
                   : `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/secrets`;
 
               await fetchResult(`${url}/${args.key}`, { method: "DELETE" });
-              console.log(`✨ Success! Deleted secret ${args.key}`);
+              logger.log(`✨ Success! Deleted secret ${args.key}`);
             }
           }
         )
@@ -1606,17 +1821,20 @@ export async function main(argv: string[]): Promise<void> {
               .option("name", {
                 describe: "Name of the worker",
                 type: "string",
+                requiresArg: true,
               })
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe:
                   "Binds the secret to the Worker of the specific environment.",
+                alias: "e",
               });
           },
           async (args) => {
-            const config = readConfig(args.config as ConfigPath);
+            const config = readConfig(args.config as ConfigPath, args);
 
-            const scriptName = getScriptName(args, config);
+            const scriptName = getLegacyScriptName(args, config);
             if (!scriptName) {
               throw new Error("Missing script name");
             }
@@ -1624,11 +1842,11 @@ export async function main(argv: string[]): Promise<void> {
             const accountId = await requireAuth(config);
 
             const url =
-              !args.env || isLegacyEnv(args, config)
+              !args.env || isLegacyEnv(config)
                 ? `/accounts/${accountId}/workers/scripts/${scriptName}/secrets`
                 : `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/secrets`;
 
-            console.log(JSON.stringify(await fetchResult(url), null, "  "));
+            logger.log(JSON.stringify(await fetchResult(url), null, "  "));
           }
         );
     }
@@ -1654,7 +1872,9 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
+                alias: "e",
               })
               .option("preview", {
                 type: "boolean",
@@ -1662,12 +1882,7 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args._.length > 2) {
-              const extraArgs = args._.slice(2).join(" ");
-              throw new CommandLineArgsError(
-                `Unexpected additional positional arguments "${extraArgs}".`
-              );
-            }
+            await printWranglerBanner();
 
             if (!isValidNamespaceBinding(args.namespace)) {
               throw new CommandLineArgsError(
@@ -1675,9 +1890,9 @@ export async function main(argv: string[]): Promise<void> {
               );
             }
 
-            const config = readConfig(args.config as ConfigPath);
+            const config = readConfig(args.config as ConfigPath, args);
             if (!config.name) {
-              console.warn(
+              logger.warn(
                 "No configured name present, using `worker` as a prefix for the title"
               );
             }
@@ -1691,16 +1906,16 @@ export async function main(argv: string[]): Promise<void> {
 
             // TODO: generate a binding name stripping non alphanumeric chars
 
-            console.log(`🌀 Creating namespace with title "${title}"`);
+            logger.log(`🌀 Creating namespace with title "${title}"`);
             const namespaceId = await createNamespace(accountId, title);
 
-            console.log("✨ Success!");
+            logger.log("✨ Success!");
             const envString = args.env ? ` under [env.${args.env}]` : "";
             const previewString = args.preview ? "preview_" : "";
-            console.log(
+            logger.log(
               `Add the following to your configuration file in your kv_namespaces array${envString}:`
             );
-            console.log(
+            logger.log(
               `{ binding = "${args.namespace}", ${previewString}id = "${namespaceId}" }`
             );
 
@@ -1712,13 +1927,13 @@ export async function main(argv: string[]): Promise<void> {
           "Outputs a list of all KV namespaces associated with your account id.",
           {},
           async (args) => {
-            const config = readConfig(args.config as ConfigPath);
+            const config = readConfig(args.config as ConfigPath, args);
 
             const accountId = await requireAuth(config);
 
             // TODO: we should show bindings if they exist for given ids
 
-            console.log(
+            logger.log(
               JSON.stringify(await listNamespaces(accountId), null, "  ")
             );
           }
@@ -1730,16 +1945,20 @@ export async function main(argv: string[]): Promise<void> {
             return yargs
               .option("binding", {
                 type: "string",
+                requiresArg: true,
                 describe: "The name of the namespace to delete",
               })
               .option("namespace-id", {
                 type: "string",
+                requiresArg: true,
                 describe: "The id of the namespace to delete",
               })
               .check(demandOneOfOption("binding", "namespace-id"))
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
+                alias: "e",
               })
               .option("preview", {
                 type: "boolean",
@@ -1747,7 +1966,8 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            const config = readConfig(args.config as ConfigPath);
+            await printWranglerBanner();
+            const config = readConfig(args.config as ConfigPath, args);
 
             let id;
             try {
@@ -1810,16 +2030,20 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("binding", {
                 type: "string",
+                requiresArg: true,
                 describe: "The binding of the namespace to write to",
               })
               .option("namespace-id", {
                 type: "string",
+                requiresArg: true,
                 describe: "The id of the namespace to write to",
               })
               .check(demandOneOfOption("binding", "namespace-id"))
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
+                alias: "e",
               })
               .option("preview", {
                 type: "boolean",
@@ -1836,12 +2060,14 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("path", {
                 type: "string",
+                requiresArg: true,
                 describe: "Read value from the file at a given path",
               })
               .check(demandOneOfOption("value", "path"));
           },
           async ({ key, ttl, expiration, ...args }) => {
-            const config = readConfig(args.config as ConfigPath);
+            await printWranglerBanner();
+            const config = readConfig(args.config as ConfigPath, args);
             const namespaceId = getNamespaceId(args, config);
             // One of `args.path` and `args.value` must be defined
             const value = args.path
@@ -1850,12 +2076,12 @@ export async function main(argv: string[]): Promise<void> {
                 args.value!;
 
             if (args.path) {
-              console.log(
-                `writing the contents of ${args.path} to the key "${key}" on namespace ${namespaceId}`
+              logger.log(
+                `Writing the contents of ${args.path} to the key "${key}" on namespace ${namespaceId}.`
               );
             } else {
-              console.log(
-                `writing the value "${value}" to key "${key}" on namespace ${namespaceId}`
+              logger.log(
+                `Writing the value "${value}" to key "${key}" on namespace ${namespaceId}.`
               );
             }
 
@@ -1876,16 +2102,20 @@ export async function main(argv: string[]): Promise<void> {
             return yargs
               .option("binding", {
                 type: "string",
+                requiresArg: true,
                 describe: "The name of the namespace to list",
               })
               .option("namespace-id", {
                 type: "string",
+                requiresArg: true,
                 describe: "The id of the namespace to list",
               })
               .check(demandOneOfOption("binding", "namespace-id"))
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
+                alias: "e",
               })
               .option("preview", {
                 type: "boolean",
@@ -1895,12 +2125,13 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("prefix", {
                 type: "string",
+                requiresArg: true,
                 describe: "A prefix to filter listed keys",
               });
           },
           async ({ prefix, ...args }) => {
             // TODO: support for limit+cursor (pagination)
-            const config = readConfig(args.config as ConfigPath);
+            const config = readConfig(args.config as ConfigPath, args);
             const namespaceId = getNamespaceId(args, config);
 
             const accountId = await requireAuth(config);
@@ -1910,7 +2141,7 @@ export async function main(argv: string[]): Promise<void> {
               namespaceId,
               prefix
             );
-            console.log(JSON.stringify(results, undefined, 2));
+            logger.log(JSON.stringify(results, undefined, 2));
           }
         )
         .command(
@@ -1925,16 +2156,20 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("binding", {
                 type: "string",
+                requiresArg: true,
                 describe: "The name of the namespace to get from",
               })
               .option("namespace-id", {
                 type: "string",
+                requiresArg: true,
                 describe: "The id of the namespace to get from",
               })
               .check(demandOneOfOption("binding", "namespace-id"))
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
+                alias: "e",
               })
               .option("preview", {
                 type: "boolean",
@@ -1948,12 +2183,12 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ key, ...args }) => {
-            const config = readConfig(args.config as ConfigPath);
+            const config = readConfig(args.config as ConfigPath, args);
             const namespaceId = getNamespaceId(args, config);
 
             const accountId = await requireAuth(config);
 
-            console.log(await getKeyValue(accountId, namespaceId, key));
+            logger.log(await getKeyValue(accountId, namespaceId, key));
           }
         )
         .command(
@@ -1968,16 +2203,20 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("binding", {
                 type: "string",
+                requiresArg: true,
                 describe: "The name of the namespace to delete from",
               })
               .option("namespace-id", {
                 type: "string",
+                requiresArg: true,
                 describe: "The id of the namespace to delete from",
               })
               .check(demandOneOfOption("binding", "namespace-id"))
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
+                alias: "e",
               })
               .option("preview", {
                 type: "boolean",
@@ -1985,11 +2224,12 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ key, ...args }) => {
-            const config = readConfig(args.config as ConfigPath);
+            await printWranglerBanner();
+            const config = readConfig(args.config as ConfigPath, args);
             const namespaceId = getNamespaceId(args, config);
 
-            console.log(
-              `deleting the key "${key}" on namespace ${namespaceId}`
+            logger.log(
+              `Deleting the key "${key}" on namespace ${namespaceId}.`
             );
 
             const accountId = await requireAuth(config);
@@ -2022,16 +2262,20 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("binding", {
                 type: "string",
+                requiresArg: true,
                 describe: "The name of the namespace to insert values into",
               })
               .option("namespace-id", {
                 type: "string",
+                requiresArg: true,
                 describe: "The id of the namespace to insert values into",
               })
               .check(demandOneOfOption("binding", "namespace-id"))
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
+                alias: "e",
               })
               .option("preview", {
                 type: "boolean",
@@ -2039,11 +2283,12 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ filename, ...args }) => {
+            await printWranglerBanner();
             // The simplest implementation I could think of.
             // This could be made more efficient with a streaming parser/uploader
             // but we'll do that in the future if needed.
 
-            const config = readConfig(args.config as ConfigPath);
+            const config = readConfig(args.config as ConfigPath, args);
             const namespaceId = getNamespaceId(args, config);
             const content = parseJSON(readFileSync(filename), filename);
 
@@ -2080,7 +2325,7 @@ export async function main(argv: string[]): Promise<void> {
               }
             }
             if (warnings.length > 0) {
-              console.warn(
+              logger.warn(
                 `Unexpected key-value properties in "${filename}".\n` +
                   warnings.join("\n")
               );
@@ -2107,11 +2352,11 @@ export async function main(argv: string[]): Promise<void> {
               namespaceId,
               content,
               (index, total) => {
-                console.log(`Uploaded ${index} of ${total}.`);
+                logger.log(`Uploaded ${index} of ${total}.`);
               }
             );
 
-            console.log("Success!");
+            logger.log("Success!");
           }
         )
         .command(
@@ -2126,16 +2371,20 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("binding", {
                 type: "string",
+                requiresArg: true,
                 describe: "The name of the namespace to delete from",
               })
               .option("namespace-id", {
                 type: "string",
+                requiresArg: true,
                 describe: "The id of the namespace to delete from",
               })
               .check(demandOneOfOption("binding", "namespace-id"))
               .option("env", {
                 type: "string",
+                requiresArg: true,
                 describe: "Perform on a specific environment",
+                alias: "e",
               })
               .option("preview", {
                 type: "boolean",
@@ -2148,7 +2397,8 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ filename, ...args }) => {
-            const config = readConfig(args.config as ConfigPath);
+            await printWranglerBanner();
+            const config = readConfig(args.config as ConfigPath, args);
             const namespaceId = getNamespaceId(args, config);
 
             if (!args.force) {
@@ -2156,7 +2406,7 @@ export async function main(argv: string[]): Promise<void> {
                 `Are you sure you want to delete all the keys read from "${filename}" from kv-namespace with id "${namespaceId}"?`
               );
               if (!result) {
-                console.log(`Not deleting keys read from "${filename}".`);
+                logger.log(`Not deleting keys read from "${filename}".`);
                 return;
               }
             }
@@ -2199,18 +2449,22 @@ export async function main(argv: string[]): Promise<void> {
               namespaceId,
               content,
               (index, total) => {
-                console.log(`Deleted ${index} of ${total}.`);
+                logger.log(`Deleted ${index} of ${total}.`);
               }
             );
 
-            console.log("Success!");
+            logger.log("Success!");
           }
         );
     }
   );
 
-  wrangler.command("pages", "⚡️ Configure Cloudflare Pages", (pagesYargs) =>
-    pages(pagesYargs.command(subHelp))
+  wrangler.command(
+    "pages",
+    "⚡️ Configure Cloudflare Pages",
+    async (pagesYargs) => {
+      await pages(pagesYargs.command(subHelp).epilogue(pagesBetaWarning));
+    }
   );
 
   wrangler.command("r2", "📦 Interact with an R2 store", (r2Yargs) => {
@@ -2228,30 +2482,24 @@ export async function main(argv: string[]): Promise<void> {
             });
           },
           async (args) => {
-            // We expect three values in `_`: `r2`, `bucket`, `create`.
-            if (args._.length > 3) {
-              const extraArgs = args._.slice(3).join(" ");
-              throw new CommandLineArgsError(
-                `Unexpected additional positional arguments "${extraArgs}".`
-              );
-            }
+            await printWranglerBanner();
 
-            const config = readConfig(args.config as ConfigPath);
+            const config = readConfig(args.config as ConfigPath, args);
 
             const accountId = await requireAuth(config);
 
-            console.log(`Creating bucket ${args.name}.`);
+            logger.log(`Creating bucket ${args.name}.`);
             await createR2Bucket(accountId, args.name);
-            console.log(`Created bucket ${args.name}.`);
+            logger.log(`Created bucket ${args.name}.`);
           }
         );
 
         r2BucketYargs.command("list", "List R2 buckets", {}, async (args) => {
-          const config = readConfig(args.config as ConfigPath);
+          const config = readConfig(args.config as ConfigPath, args);
 
           const accountId = await requireAuth(config);
 
-          console.log(JSON.stringify(await listR2Buckets(accountId), null, 2));
+          logger.log(JSON.stringify(await listR2Buckets(accountId), null, 2));
         });
 
         r2BucketYargs.command(
@@ -2265,27 +2513,97 @@ export async function main(argv: string[]): Promise<void> {
             });
           },
           async (args) => {
-            // We expect three values in `_`: `r2`, `bucket`, `delete`.
-            if (args._.length > 3) {
-              const extraArgs = args._.slice(3).join(" ");
-              throw new CommandLineArgsError(
-                `Unexpected additional positional arguments "${extraArgs}".`
-              );
-            }
+            await printWranglerBanner();
 
-            const config = readConfig(args.config as ConfigPath);
+            const config = readConfig(args.config as ConfigPath, args);
 
             const accountId = await requireAuth(config);
 
-            console.log(`Deleting bucket ${args.name}.`);
+            logger.log(`Deleting bucket ${args.name}.`);
             await deleteR2Bucket(accountId, args.name);
-            console.log(`Deleted bucket ${args.name}.`);
+            logger.log(`Deleted bucket ${args.name}.`);
           }
         );
         return r2BucketYargs;
       });
   });
 
+  /**
+   * User Group: login, logout, and whoami
+   * TODO: group commands into User group similar to .group() for flags in yargs
+   */
+  // login
+  wrangler.command(
+    // this needs scopes as an option?
+    "login",
+    "🔓 Login to Cloudflare",
+    (yargs) => {
+      // TODO: This needs some copy editing
+      // I mean, this entire app does, but this too.
+      return yargs
+        .option("scopes-list", {
+          describe: "List all the available OAuth scopes with descriptions",
+        })
+        .option("scopes", {
+          describe: "Pick the set of applicable OAuth scopes when logging in",
+          array: true,
+          type: "string",
+          requiresArg: true,
+        });
+
+      // TODO: scopes
+    },
+    async (args) => {
+      await printWranglerBanner();
+      if (args["scopes-list"]) {
+        listScopes();
+        return;
+      }
+      if (args.scopes) {
+        if (args.scopes.length === 0) {
+          // don't allow no scopes to be passed, that would be weird
+          listScopes();
+          return;
+        }
+        if (!validateScopeKeys(args.scopes)) {
+          throw new CommandLineArgsError(
+            `One of ${args.scopes} is not a valid authentication scope. Run "wrangler login --list-scopes" to see the valid scopes.`
+          );
+        }
+        await login({ scopes: args.scopes });
+        return;
+      }
+      await login();
+
+      // TODO: would be nice if it optionally saved login
+      // credentials inside node_modules/.cache or something
+      // this way you could have multiple users on a single machine
+    }
+  );
+
+  // logout
+  wrangler.command(
+    // this needs scopes as an option?
+    "logout",
+    "🚪 Logout from Cloudflare",
+    () => {},
+    async () => {
+      await printWranglerBanner();
+      await logout();
+    }
+  );
+
+  // whoami
+  wrangler.command(
+    "whoami",
+    "🕵️  Retrieve your user info and test your auth config",
+    () => {},
+    async () => {
+      await printWranglerBanner();
+      await whoami();
+    }
+  );
+
   wrangler
     .option("legacy-env", {
       type: "boolean",
@@ -2295,6 +2613,7 @@ export async function main(argv: string[]): Promise<void> {
       alias: "c",
       describe: "Path to .toml configuration file",
       type: "string",
+      requiresArg: true,
     });
 
   wrangler.group(["config", "help", "version", "legacy-env"], "Flags:");
@@ -2303,23 +2622,21 @@ export async function main(argv: string[]): Promise<void> {
   wrangler.exitProcess(false);
 
   try {
-    await initialiseUserConfig();
     await wrangler.parse();
   } catch (e) {
+    logger.log(""); // Just adds a bit of space
     if (e instanceof CommandLineArgsError) {
       wrangler.showHelp("error");
-      console.error(""); // Just adds a bit of space
-      console.error(e.message);
+      logger.log(""); // Add a bit of space.
+      logger.error(e.message);
     } else if (e instanceof ParseError) {
-      console.error("");
       e.notes.push({
         text: "\nIf you think this is a bug, please open an issue at: https://github.com/cloudflare/wrangler2/issues/new",
       });
-      console.error(formatMessage(e));
+      logger.error(formatMessage(e));
     } else {
-      console.error(e instanceof Error ? e.message : e);
-      console.error(""); // Just adds a bit of space
-      console.error(
+      logger.error(e instanceof Error ? e.message : e);
+      logger.log(
         `${fgGreenColor}%s${resetColor}`,
         "If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       );
@@ -2327,3 +2644,25 @@ export async function main(argv: string[]): Promise<void> {
     throw e;
   }
 }
+
+function getDevCompatibilityDate(
+  config: Config,
+  compatibilityDate = config.compatibility_date
+) {
+  const currentDate = new Date().toISOString().substring(0, 10);
+  if (config.configPath !== undefined && compatibilityDate === undefined) {
+    logger.warn(
+      `No compatibility_date was specified. Using today's date: ${currentDate}.\n` +
+        "Add one to your wrangler.toml file:\n" +
+        "```\n" +
+        `compatibility_date = "${currentDate}"\n` +
+        "```\n" +
+        "or pass it in your terminal:\n" +
+        "```\n" +
+        `--compatibility-date=${currentDate}\n` +
+        "```\n" +
+        "See https://developers.cloudflare.com/workers/platform/compatibility-dates for more information."
+    );
+  }
+  return compatibilityDate ?? currentDate;
+}