wrangler 0.0.0-e1c615f → 0.0.0-e3cab74

package/src/index.tsx

@@ -1,22 +1,21 @@
-import React from "react";
+import * as fs from "node:fs";
+import { writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { setTimeout } from "node:timers/promises";
+import TOML from "@iarna/toml";
+import { findUp } from "find-up";
+import getPort from "get-port";
 import { render } from "ink";
-import Dev from "./dev";
-import { readFile } from "node:fs/promises";
+import React from "react";
+import onExit from "signal-exit";
 import makeCLI from "yargs";
-import type Yargs from "yargs";
-import { findUp } from "find-up";
-import TOML from "@iarna/toml";
-import type { Config } from "./config";
-import { confirm, prompt } from "./dialogs";
 import { version as wranglerVersion } from "../package.json";
-import {
-  login,
-  logout,
-  listScopes,
-  initialise as initialiseUserConfig,
-  loginOrRefreshIfRequired,
-  getAccountId,
-} from "./user";
+import { toFormData } from "./api/form_data";
+import { fetchResult } from "./cfetch";
+import { findWranglerToml, readConfig } from "./config";
+import Dev from "./dev";
+import { confirm, prompt } from "./dialogs";
+import { getEntry } from "./entry";
 import {
   getNamespaceId,
   listNamespaces,
@@ -26,92 +25,79 @@ import {
   deleteBulkKeyValue,
   createNamespace,
   isValidNamespaceBinding,
+  getKeyValue,
 } from "./kv";
-
+import { getPackageManager } from "./package-manager";
 import { pages } from "./pages";
-
-import { fetchResult, fetchRaw } from "./cfetch";
-
+import { formatMessage, ParseError, parseJSON, readFileSync } from "./parse";
 import publish from "./publish";
-import path from "path/posix";
-import { writeFile } from "node:fs/promises";
-import { toFormData } from "./api/form_data";
+import { createR2Bucket, deleteR2Bucket, listR2Buckets } from "./r2";
+import { getAssetPaths } from "./sites";
+import {
+  createTail,
+  jsonPrintLogs,
+  prettyPrintLogs,
+  translateCLICommandToFilterMessage,
+} from "./tail";
+import {
+  login,
+  logout,
+  listScopes,
+  initialise as initialiseUserConfig,
+  loginOrRefreshIfRequired,
+  getAccountId,
+  validateScopeKeys,
+} from "./user";
+import { whoami } from "./whoami";
 
-import { createTail } from "./tail";
-import onExit from "signal-exit";
-import { setTimeout } from "node:timers/promises";
-import * as fs from "node:fs";
-import { execa } from "execa";
+import type { Config } from "./config";
+import type { TailCLIFilters } from "./tail";
+import type { RawData } from "ws";
+import type Yargs from "yargs";
 
-async function readConfig(configPath?: string): Promise<Config> {
-  const config: Config = {};
-  if (!configPath) {
-    configPath = await findUp("wrangler.toml");
-    // TODO - terminate this early instead of going all the way to the root
-  }
+type ConfigPath = string | undefined;
 
-  if (configPath) {
-    const tml: string = await readFile(configPath, "utf-8");
-    const parsed = TOML.parse(tml) as Config;
-    Object.assign(config, parsed);
-  }
+const resetColor = "\x1b[0m";
+const fgGreenColor = "\x1b[32m";
 
-  const inheritedFields = [
-    "name",
-    "account_id",
-    "workers_dev",
-    "compatibility_date",
-    "compatibility_flags",
-    "zone_id",
-    "routes",
-    "route",
-    "jsx_factory",
-    "jsx_fragment",
-    "site",
-    "triggers",
-    "usage_model",
-  ];
-
-  Object.keys(config.env || {}).forEach((env) => {
-    inheritedFields.forEach((field) => {
-      if (config[field] !== undefined && config.env[env][field] === undefined) {
-        config.env[env][field] = config[field]; // TODO: - shallow copy?
-      }
-    });
-  });
+function getRules(config: Config): Config["rules"] {
+  const rules = config.rules ?? config.build?.upload?.rules ?? [];
 
-  const mirroredFields = [
-    "vars",
-    "kv_namespaces",
-    "durable_objects",
-    "experimental_services",
-  ];
-  Object.keys(config.env || {}).forEach((env) => {
-    mirroredFields.forEach((field) => {
-      // if it exists on top level, it should exist on env definitions
-      Object.keys(config[field] || {}).forEach((fieldKey) => {
-        if (!(fieldKey in config.env[env][field])) {
-          console.warn(
-            `In your configuration, "${field}.${fieldKey}" exists at a top level, but not on "env.${env}". This is not what you probably want, since the field "${field}" is not inherited by environments. Please add "${field}.${fieldKey}" to "env.${env}".`
-          );
-        }
-      });
-    });
-  });
+  if (config.rules && config.build?.upload?.rules) {
+    throw new Error(
+      `You cannot configure both [rules] and [build.upload.rules] in your wrangler.toml. Delete the \`build.upload\` section.`
+    );
+  }
 
-  if ("experimental_services" in config) {
+  if (config.build?.upload?.rules) {
     console.warn(
-      "The experimental_services field is only for cloudflare internal usage right now, and is subject to change. Please do not use this on production projects"
+      `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:
+
+${TOML.stringify({ rules: config.build.upload.rules })}`
     );
   }
+  return rules;
+}
 
-  // todo: validate, add defaults
-  // let's just do some basics for now
+function isLegacyEnv(args: unknown, config: Config): boolean {
+  return (
+    (args as { "legacy-env": boolean | undefined })["legacy-env"] ??
+    config.legacy_env
+  );
+}
 
-  // @ts-expect-error we're being sneaky here for now
-  config.__path__ = configPath;
+function getScriptName(
+  args: { name: string | undefined; env: string | undefined },
+  config: Config
+): string | undefined {
+  const shortScriptName = args.name ?? config.name;
+  if (!shortScriptName) {
+    return;
+  }
 
-  return config;
+  return isLegacyEnv(args, config)
+    ? `${shortScriptName}${args.env ? `-${args.env}` : ""}`
+    : shortScriptName;
 }
 
 // a helper to demand one of a set of options
@@ -140,8 +126,11 @@ function demandOneOfOption(...options: string[]) {
 }
 
 class CommandLineArgsError extends Error {}
-class DeprecationError extends Error {}
-class NotImplementedError 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)
@@ -210,10 +199,16 @@ export async function main(argv: string[]): Promise<void> {
     "init [name]",
     "📥 Create a wrangler.toml configuration file",
     (yargs) => {
-      return yargs.positional("name", {
-        describe: "The name of your worker.",
-        type: "string",
-      });
+      return yargs
+        .positional("name", {
+          describe: "The name of your worker",
+          type: "string",
+        })
+        .option("yes", {
+          describe: 'Answer "yes" to any prompts for new projects',
+          type: "boolean",
+          alias: "y",
+        });
     },
     async (args) => {
       if ("type" in args) {
@@ -226,94 +221,285 @@ export async function main(argv: string[]): Promise<void> {
         throw new CommandLineArgsError(message);
       }
 
-      const destination = path.join(process.cwd(), "wrangler.toml");
-      if (fs.existsSync(destination)) {
-        console.warn(`${destination} file already exists!`);
-        const result = await confirm(
+      // TODO: make sure args.name is a valid identifier for a worker name
+
+      const creationDirectory = path.join(process.cwd(), args.name ?? "");
+
+      const packageManager = await getPackageManager(creationDirectory);
+
+      // TODO: ask which directory to make the worker in (defaults to args.name)
+      // TODO: if args.name isn't provided, ask what to name the worker
+
+      const wranglerTomlDestination = path.join(
+        creationDirectory,
+        "./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!`);
+        const shouldContinue = await confirm(
           "Do you want to continue initializing this project?"
         );
-        if (!result) {
+        if (!shouldContinue) {
           return;
         }
+      } else {
+        await mkdir(creationDirectory, { recursive: true });
+        const compatibilityDate = new Date().toISOString().substring(0, 10);
+        try {
+          await writeFile(
+            wranglerTomlDestination,
+            TOML.stringify({
+              name: workerName,
+              compatibility_date: compatibilityDate,
+            }) + "\n"
+          );
+          console.log(`✨ Successfully created wrangler.toml`);
+          justCreatedWranglerToml = true;
+        } catch (err) {
+          throw new Error(
+            `Failed to create wrangler.toml.\n${(err as Error).message ?? err}`
+          );
+        }
       }
 
-      const compatibilityDate = new Date().toISOString().substring(0, 10);
-      try {
-        await writeFile(
-          destination,
-          `compatibility_date = "${compatibilityDate}"` + "\n"
-        );
-        console.log(`✨ Successfully created wrangler.toml`);
-        // TODO: suggest next steps?
-      } catch (err) {
-        throw new Error(
-          `Failed to create wrangler.toml.\n${err.message ?? err}`
-        );
-      }
-
-      // if no package.json, ask, and if yes, create one
       let pathToPackageJson = await findUp("package.json");
-
+      let shouldCreatePackageJson = false;
+      const yesFlag = args.yes ?? false;
       if (!pathToPackageJson) {
-        if (
-          await confirm("No package.json found. Would you like to create one?")
-        ) {
+        // If no package.json exists, ask to create one
+        shouldCreatePackageJson =
+          yesFlag ||
+          (await confirm(
+            "No package.json found. Would you like to create one?"
+          ));
+
+        if (shouldCreatePackageJson) {
           await writeFile(
-            path.join(process.cwd(), "package.json"),
+            path.join(creationDirectory, "./package.json"),
             JSON.stringify(
               {
-                name: "worker",
-                version: "0.0.1",
+                name: workerName,
+                version: "0.0.0",
+                devDependencies: {
+                  wrangler: wranglerVersion,
+                },
+                private: true,
               },
               null,
               "  "
             ) + "\n"
           );
+          await packageManager.install();
           console.log(`✨ Created package.json`);
-          pathToPackageJson = path.join(process.cwd(), "package.json");
+          pathToPackageJson = path.join(creationDirectory, "package.json");
         } else {
           return;
         }
+      } else {
+        // If package.json exists and wrangler isn't installed,
+        // then ask to add wrangler to devDependencies
+        const packageJson = parseJSON(
+          readFileSync(pathToPackageJson),
+          pathToPackageJson
+        );
+        if (
+          !(
+            packageJson.devDependencies?.wrangler ||
+            packageJson.dependencies?.wrangler
+          )
+        ) {
+          const shouldInstall =
+            yesFlag ||
+            (await confirm(
+              "Would you like to install wrangler into your package.json?"
+            ));
+          if (shouldInstall) {
+            await packageManager.addDevDeps(`wrangler@${wranglerVersion}`);
+            console.log(`✨ Installed wrangler`);
+          }
+        }
       }
 
-      // if workers-types doesn't exist as a dependency
-      // offer to install it
-      // and make a tsconfig?
+      let isTypescriptProject = false;
       let pathToTSConfig = await findUp("tsconfig.json");
       if (!pathToTSConfig) {
-        if (await confirm("Would you like to use typescript?")) {
+        // If there's no tsconfig, offer to create one
+        // and install @cloudflare/workers-types
+        if (yesFlag || (await confirm("Would you like to use TypeScript?"))) {
+          isTypescriptProject = true;
           await writeFile(
-            path.join(process.cwd(), "tsconfig.json"),
+            path.join(creationDirectory, "./tsconfig.json"),
+            readFileSync(path.join(__dirname, "../templates/tsconfig.json"))
+          );
+          await packageManager.addDevDeps(
+            "@cloudflare/workers-types",
+            "typescript"
+          );
+
+          console.log(
+            `✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies`
+          );
+          pathToTSConfig = path.join(creationDirectory, "tsconfig.json");
+        }
+      } else {
+        isTypescriptProject = true;
+        // If there's a tsconfig, check if @cloudflare/workers-types
+        // is already installed, and offer to install it if not
+        const packageJson = parseJSON(
+          readFileSync(pathToPackageJson),
+          pathToPackageJson
+        );
+        if (
+          !(
+            packageJson.devDependencies?.["@cloudflare/workers-types"] ||
+            packageJson.dependencies?.["@cloudflare/workers-types"]
+          )
+        ) {
+          const shouldInstall = await confirm(
+            "Would you like to install the type definitions for Workers into your package.json?"
+          );
+          if (shouldInstall) {
+            await packageManager.addDevDeps("@cloudflare/workers-types");
+            // We don't update the tsconfig.json because
+            // 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`
+            );
+          }
+        }
+      }
+
+      const packageJsonContent = parseJSON(
+        readFileSync(pathToPackageJson),
+        pathToPackageJson
+      );
+      const shouldWritePackageJsonScripts =
+        !packageJsonContent.scripts?.start &&
+        !packageJsonContent.scripts?.publish &&
+        shouldCreatePackageJson;
+
+      async function writePackageJsonScriptsAndUpdateWranglerToml(
+        isWritingScripts: boolean,
+        isCreatingWranglerToml: boolean,
+        packagePath: string,
+        scriptPath: string
+      ) {
+        if (isCreatingWranglerToml) {
+          // rewrite wrangler.toml with main = "path/to/script"
+          const parsedWranglerToml = TOML.parse(
+            readFileSync(wranglerTomlDestination)
+          );
+          fs.writeFileSync(
+            wranglerTomlDestination,
+            TOML.stringify({
+              name: parsedWranglerToml.name,
+              main: scriptPath,
+              compatibility_date: parsedWranglerToml.compatibility_date,
+            })
+          );
+        }
+        const isNamedWorker =
+          isCreatingWranglerToml && path.dirname(packagePath) !== process.cwd();
+
+        if (isWritingScripts) {
+          await writeFile(
+            packagePath,
             JSON.stringify(
               {
-                compilerOptions: {
-                  target: "esnext",
-                  module: "esnext",
-                  moduleResolution: "node",
-                  esModuleInterop: true,
-                  allowJs: true,
-                  allowSyntheticDefaultImports: true,
-                  isolatedModules: true,
-                  noEmit: true,
-                  lib: ["esnext"],
-                  jsx: "react",
-                  resolveJsonModule: true,
-                  types: ["@cloudflare/workers-types"],
+                ...packageJsonContent,
+                scripts: {
+                  ...packageJsonContent.scripts,
+                  start: isCreatingWranglerToml
+                    ? `wrangler dev`
+                    : `wrangler dev ${scriptPath}`,
+                  publish: isCreatingWranglerToml
+                    ? `wrangler publish`
+                    : `wrangler publish ${scriptPath}`,
                 },
               },
               null,
-              "  "
+              2
             ) + "\n"
           );
-          await execa("npm", [
-            "install",
-            "@cloudflare/workers-types",
-            "--save-dev",
-          ]);
           console.log(
-            `✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies`
+            `\nTo start developing your Worker, run \`${
+              isNamedWorker ? `cd ${args.name} && ` : ""
+            }npm start\``
+          );
+          console.log(
+            `To publish your Worker to the Internet, run \`npm run publish\``
+          );
+        } else {
+          console.log(
+            `\nTo start developing your Worker, run \`npx wrangler dev\`${
+              isCreatingWranglerToml ? "" : ` ${scriptPath}`
+            }`
           );
-          pathToTSConfig = path.join(process.cwd(), "tsconfig.json");
+          console.log(
+            `To publish your Worker to the Internet, run \`npx wrangler publish\`${
+              isCreatingWranglerToml ? "" : ` ${scriptPath}`
+            }`
+          );
+        }
+      }
+
+      if (isTypescriptProject) {
+        if (!fs.existsSync(path.join(creationDirectory, "./src/index.ts"))) {
+          let shouldCreateSource = false;
+
+          shouldCreateSource =
+            yesFlag ||
+            (await confirm(
+              `Would you like to create a Worker at src/index.ts?`
+            ));
+
+          if (shouldCreateSource) {
+            await mkdir(path.join(creationDirectory, "./src"), {
+              recursive: true,
+            });
+            await writeFile(
+              path.join(creationDirectory, "./src/index.ts"),
+              readFileSync(path.join(__dirname, "../templates/new-worker.ts"))
+            );
+
+            console.log(`✨ Created src/index.ts`);
+
+            await writePackageJsonScriptsAndUpdateWranglerToml(
+              shouldWritePackageJsonScripts,
+              justCreatedWranglerToml,
+              pathToPackageJson,
+              "src/index.ts"
+            );
+          }
+        }
+      } else {
+        if (!fs.existsSync("./src/index.js")) {
+          const shouldCreateSource = await confirm(
+            `Would you like to create a Worker at src/index.js?`
+          );
+          if (shouldCreateSource) {
+            await mkdir(path.join(creationDirectory, "./src"), {
+              recursive: true,
+            });
+            await writeFile(
+              path.join(path.join(creationDirectory, "./src/index.js")),
+              readFileSync(path.join(__dirname, "../templates/new-worker.js"))
+            );
+
+            console.log(`✨ Created src/index.js`);
+
+            await writePackageJsonScriptsAndUpdateWranglerToml(
+              shouldWritePackageJsonScripts,
+              justCreatedWranglerToml,
+              pathToPackageJson,
+              "src/index.js"
+            );
+          }
         }
       }
     }
@@ -347,10 +533,10 @@ export async function main(argv: string[]): Promise<void> {
       // I mean, this entire app does, but this too.
       return yargs
         .option("scopes-list", {
-          describe: "list all the available OAuth scopes with descriptions.",
+          describe: "List all the available OAuth scopes with descriptions",
         })
         .option("scopes", {
-          describe: "allows to choose your set of OAuth scopes.",
+          describe: "Pick the set of applicable OAuth scopes when logging in",
           array: true,
           type: "string",
         });
@@ -368,6 +554,11 @@ export async function main(argv: string[]): Promise<void> {
           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;
       }
@@ -394,11 +585,10 @@ export async function main(argv: string[]): Promise<void> {
   // whoami
   wrangler.command(
     "whoami",
-    false, // we don't need to show this the menu
-    // "🕵️  Retrieve your user info and test your auth config",
+    "🕵️  Retrieve your user info and test your auth config",
     () => {},
-    (args) => {
-      console.log(":whoami", args);
+    async () => {
+      await whoami();
     }
   );
 
@@ -417,13 +607,16 @@ export async function main(argv: string[]): Promise<void> {
 
   // dev
   wrangler.command(
-    "dev <filename>",
+    "dev [script]",
     "👂 Start a local server for developing your worker",
     (yargs) => {
       return yargs
-        .positional("filename", { describe: "entry point", type: "string" })
+        .positional("script", {
+          describe: "The path to an entry point for your worker",
+          type: "string",
+        })
         .option("name", {
-          describe: "name of the script",
+          describe: "Name of the worker",
           type: "string",
         })
         .option("format", {
@@ -433,7 +626,20 @@ export async function main(argv: string[]): Promise<void> {
         .option("env", {
           describe: "Perform on a specific environment",
           type: "string",
-          // TODO: get choices for the toml file?
+        })
+        .option("compatibility-date", {
+          describe: "Date to use for compatibility checks",
+          type: "string",
+        })
+        .option("compatibility-flags", {
+          describe: "Flags to use for compatibility checks",
+          type: "array",
+          alias: "compatibility-flag",
+        })
+        .option("latest", {
+          describe: "Use the latest version of the worker runtime",
+          type: "boolean",
+          default: true,
         })
         .option("ip", {
           describe: "IP address to listen on",
@@ -441,9 +647,12 @@ export async function main(argv: string[]): Promise<void> {
           default: "127.0.0.1",
         })
         .option("port", {
-          describe: "Port to listen on, defaults to 8787",
+          describe: "Port to listen on",
+          type: "number",
+        })
+        .option("inspector-port", {
+          describe: "Port for devtools to connect to",
           type: "number",
-          default: 8787,
         })
         .option("host", {
           type: "string",
@@ -463,6 +672,18 @@ export async function main(argv: string[]): Promise<void> {
           describe: "Root folder of static assets for Workers Sites",
           type: "string",
         })
+        .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",
+          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",
+          array: true,
+        })
         .option("upstream-protocol", {
           default: "https",
           describe:
@@ -476,11 +697,24 @@ export async function main(argv: string[]): Promise<void> {
         .option("jsx-fragment", {
           describe: "The function that is called for each JSX fragment",
           type: "string",
+        })
+        .option("local", {
+          alias: "l",
+          describe: "Run on my machine",
+          type: "boolean",
+          default: false, // I bet this will a point of contention. We'll revisit it.
+        })
+        .option("experimental-enable-local-persistence", {
+          describe: "Enable persistence for this session (only for local mode)",
+          type: "boolean",
         });
     },
     async (args) => {
-      const { filename, format } = args;
-      const config = args.config as Config;
+      const config = readConfig(
+        (args.config as ConfigPath) ||
+          (args.script && findWranglerToml(path.dirname(args.script)))
+      );
+      const entry = getEntry(config, "dev", args.script);
 
       if (args["experimental-public"]) {
         console.warn(
@@ -494,54 +728,75 @@ export async function main(argv: string[]): Promise<void> {
         );
       }
 
-      // -- snip, extract --
+      if (config.site?.["entry-point"]) {
+        console.warn(
+          "Deprecation notice: The `site.entry-point` config field is no longer used.\n" +
+            "The entry-point is specified via the command line (e.g. `wrangler dev path/to/script`).\n" +
+            "Please remove the `site.entry-point` field from the `wrangler.toml` file."
+        );
+      }
 
       if (!args.local) {
+        // -- snip, extract --
         const loggedIn = await loginOrRefreshIfRequired();
         if (!loggedIn) {
           // didn't login, let's just quit
           console.log("Did not login, quitting...");
           return;
         }
+
         if (!config.account_id) {
           config.account_id = await getAccountId();
           if (!config.account_id) {
             throw new Error("No account id found, quitting...");
           }
         }
+        // -- snip, end --
       }
 
-      // -- snip, end --
-
-      const envRootObj = args.env ? config.env[args.env] || {} : config;
-
-      // TODO: this error shouldn't actually happen,
-      // but we haven't fixed it internally yet
-      if ("durable_objects" in envRootObj) {
-        if (!(args.name || config.name)) {
-          console.warn(
-            'A worker with durable objects need to be named, or it may not work as expected. Add a "name" into wrangler.toml, or pass it in the command line with --name.'
-          );
-        }
-        // TODO: if not already published, publish a draft worker
-      }
+      const environments = config.env ?? {};
+      const envRootObj = args.env ? environments[args.env] || {} : config;
 
       const { waitUntilExit } = render(
         <Dev
-          name={args.name || config.name}
-          entry={path.relative(process.cwd(), filename)}
+          name={getScriptName(args, config)}
+          entry={entry}
+          env={args.env}
+          zone={undefined}
+          rules={getRules(config)}
+          legacyEnv={isLegacyEnv(args, config)}
           buildCommand={config.build || {}}
-          format={format}
+          format={args.format || config.build?.upload?.format}
           initialMode={args.local ? "local" : "remote"}
           jsxFactory={args["jsx-factory"] || envRootObj?.jsx_factory}
           jsxFragment={args["jsx-fragment"] || envRootObj?.jsx_fragment}
+          enableLocalPersistence={
+            args["experimental-enable-local-persistence"] || false
+          }
           accountId={config.account_id}
-          site={args.site || config.site?.bucket}
-          port={args.port || config.dev?.port}
+          assetPaths={getAssetPaths(
+            config,
+            args.site,
+            args.siteInclude,
+            args.siteExclude
+          )}
+          port={
+            args.port || config.dev?.port || (await getPort({ port: 8787 }))
+          }
+          inspectorPort={
+            args["inspector-port"] ?? (await getPort({ port: 9229 }))
+          }
           public={args["experimental-public"]}
-          compatibilityDate={config.compatibility_date}
-          compatibilityFlags={config.compatibility_flags}
-          usageModel={config.usage_model}
+          compatibilityDate={
+            args["compatibility-date"] ||
+            config.compatibility_date ||
+            new Date().toISOString().substring(0, 10)
+          }
+          compatibilityFlags={
+            (args["compatibility-flags"] as string[]) ||
+            config.compatibility_flags
+          }
+          usageModel={envRootObj.usage_model}
           bindings={{
             kv_namespaces: envRootObj.kv_namespaces?.map(
               ({ binding, preview_id, id: _id }) => {
@@ -565,8 +820,11 @@ export async function main(argv: string[]): Promise<void> {
               }
             ),
             vars: envRootObj.vars,
+            wasm_modules: config.wasm_modules,
+            text_blobs: config.text_blobs,
             durable_objects: envRootObj.durable_objects,
-            services: envRootObj.experimental_services,
+            r2_buckets: envRootObj.r2_buckets,
+            unsafe: envRootObj.unsafe?.bindings,
           }}
         />
       );
@@ -585,13 +843,31 @@ export async function main(argv: string[]): Promise<void> {
           describe: "Perform on a specific environment",
         })
         .positional("script", {
-          describe: "script to upload",
+          describe: "The path to an entry point for your worker",
           type: "string",
         })
         .option("name", {
-          describe: "name to use when uploading",
+          describe: "Name of the worker",
+          type: "string",
+        })
+        .option("format", {
+          choices: ["modules", "service-worker"] as const,
+          describe: "Choose an entry type",
+        })
+        .option("compatibility-date", {
+          describe: "Date to use for compatibility checks",
           type: "string",
         })
+        .option("compatibility-flags", {
+          describe: "Flags to use for compatibility checks",
+          type: "array",
+          alias: "compatibility-flag",
+        })
+        .option("latest", {
+          describe: "Use the latest version of the worker runtime",
+          type: "boolean",
+          default: false,
+        })
         .option("experimental-public", {
           describe: "Static assets to be served",
           type: "string",
@@ -600,22 +876,28 @@ export async function main(argv: string[]): Promise<void> {
           describe: "Root folder of static assets for Workers Sites",
           type: "string",
         })
+        .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",
+          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",
+          array: true,
+        })
         .option("triggers", {
           describe: "cron schedules to attach",
           alias: ["schedule", "schedules"],
           type: "array",
         })
         .option("routes", {
-          describe: "routes to upload",
+          describe: "Routes to upload",
           alias: "route",
           type: "array",
         })
-        .option("services", {
-          describe: "experimental support for services",
-          type: "boolean",
-          default: "false",
-          hidden: true,
-        })
         .option("jsx-factory", {
           describe: "The function that is called for each JSX element",
           type: "string",
@@ -626,12 +908,6 @@ export async function main(argv: string[]): Promise<void> {
         });
     },
     async (args) => {
-      if (args.local) {
-        throw new NotImplementedError(
-          "🚫  Local publishing is not yet supported"
-        );
-      }
-
       if (args["experimental-public"]) {
         console.warn(
           "🚨  The --experimental-public field is experimental and will change in the future."
@@ -643,37 +919,58 @@ export async function main(argv: string[]): Promise<void> {
         );
       }
 
-      const config = args.config as Config;
+      const config = readConfig(
+        (args.config as ConfigPath) ||
+          (args.script && findWranglerToml(path.dirname(args.script)))
+      );
+      const entry = getEntry(config, "publish", args.script);
+
+      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"
+        );
+      }
 
       // -- snip, extract --
-      if (!args.local) {
-        const loggedIn = await loginOrRefreshIfRequired();
-        if (!loggedIn) {
-          // didn't login, let's just quit
-          console.log("Did not login, quitting...");
-          return;
-        }
+      const loggedIn = await loginOrRefreshIfRequired();
+      if (!loggedIn) {
+        // didn't login, let's just quit
+        console.log("Did not login, quitting...");
+        return;
+      }
+
+      if (!config.account_id) {
+        config.account_id = await getAccountId();
         if (!config.account_id) {
-          config.account_id = await getAccountId();
-          if (!config.account_id) {
-            throw new Error("No account id found, quitting...");
-          }
+          throw new Error("No account id found, quitting...");
         }
       }
-
       // -- snip, end --
 
+      const assetPaths = getAssetPaths(
+        config,
+        args["experimental-public"] || args.site,
+        args.siteInclude,
+        args.siteExclude
+      );
       await publish({
-        config: args.config as Config,
-        name: args.name,
-        script: args.script,
+        config,
+        name: getScriptName(args, config),
+        rules: getRules(config),
+        format: args.format || config.build?.upload?.format,
+        entry,
         env: args.env,
+        compatibilityDate: args.latest
+          ? new Date().toISOString().substring(0, 10)
+          : args["compatibility-date"],
+        compatibilityFlags: args["compatibility-flags"] as string[],
         triggers: args.triggers,
         jsxFactory: args["jsx-factory"],
         jsxFragment: args["jsx-fragment"],
         routes: args.routes,
-        public: args["experimental-public"],
-        site: args.site,
+        assetPaths,
+        legacyEnv: isLegacyEnv(args, config),
+        experimentalPublic: args["experimental-public"] !== undefined,
       });
     }
   );
@@ -681,12 +978,12 @@ export async function main(argv: string[]): Promise<void> {
   // tail
   wrangler.command(
     "tail [name]",
-    "🦚 Starts a log tailing session for a deployed Worker.",
+    "🦚 Starts a log tailing session for a published Worker.",
     (yargs) => {
       return (
         yargs
           .positional("name", {
-            describe: "name of the worker",
+            describe: "Name of the worker",
             type: "string",
           })
           // TODO: auto-detect if this should be json or pretty based on atty
@@ -698,6 +995,7 @@ export async function main(argv: string[]): Promise<void> {
           .option("status", {
             choices: ["ok", "error", "canceled"],
             describe: "Filter by invocation status",
+            array: true,
           })
           .option("header", {
             type: "string",
@@ -706,6 +1004,7 @@ export async function main(argv: string[]): Promise<void> {
           .option("method", {
             type: "string",
             describe: "Filter by HTTP method",
+            array: true,
           })
           .option("sampling-rate", {
             type: "number",
@@ -715,54 +1014,76 @@ export async function main(argv: string[]): Promise<void> {
             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.",
+          })
       );
-      // TODO: filter by client ip, which can be 'self' or an ip address
     },
     async (args) => {
-      const config = args.config as Config;
+      const config = readConfig(args.config as ConfigPath);
+
+      const scriptName = getScriptName(args, config);
 
-      if (!(args.name || config.name)) {
+      if (!scriptName) {
         throw new Error("Missing script name");
       }
-      const scriptName = `${args.name || config.name}${
-        args.env ? `-${args.env}` : ""
-      }`;
 
       // -- snip, extract --
+      const loggedIn = await loginOrRefreshIfRequired();
+      if (!loggedIn) {
+        // didn't login, let's just quit
+        console.log("Did not login, quitting...");
+        return;
+      }
 
-      if (!args.local) {
-        const loggedIn = await loginOrRefreshIfRequired();
-        if (!loggedIn) {
-          // didn't login, let's just quit
-          console.log("Did not login, quitting...");
-          return;
-        }
+      if (!config.account_id) {
+        config.account_id = await getAccountId();
         if (!config.account_id) {
-          config.account_id = await getAccountId();
-          if (!config.account_id) {
-            throw new Error("No account id found, quitting...");
-          }
+          throw new Error("No account id found, quitting...");
         }
       }
-
       // -- snip, end --
 
       const accountId = config.account_id;
 
-      const filters = {
-        status: args.status as "ok" | "error" | "canceled",
+      const cliFilters: TailCLIFilters = {
+        status: args.status as ("ok" | "error" | "canceled")[],
         header: args.header,
         method: args.method,
-        "sampling-rate": args["sampling-rate"],
+        samplingRate: args["sampling-rate"],
         search: args.search,
+        clientIp: args.ip,
       };
 
-      const { tail, expiration, /* sendHeartbeat, */ deleteTail } =
-        await createTail(accountId, scriptName, filters);
+      const filters = translateCLICommandToFilterMessage(
+        cliFilters,
+        args.debug
+      );
+
+      const { tail, expiration, deleteTail } = await createTail(
+        accountId,
+        scriptName,
+        filters,
+        !isLegacyEnv(args, config) ? args.env : undefined
+      );
+
+      const scriptDisplayName = `${scriptName}${
+        args.env && !isLegacyEnv(args, config) ? ` (${args.env})` : ""
+      }`;
 
       console.log(
         `successfully created tail, expires at ${expiration.toLocaleString()}`
@@ -773,24 +1094,32 @@ export async function main(argv: string[]): Promise<void> {
         await deleteTail();
       });
 
-      tail.on("message", (data) => {
-        console.log(JSON.stringify(JSON.parse(data.toString()), null, "  "));
-      });
+      const printLog: (data: RawData) => void =
+        args.format === "pretty" ? prettyPrintLogs : jsonPrintLogs;
+
+      tail.on("message", printLog);
 
       while (tail.readyState !== tail.OPEN) {
         switch (tail.readyState) {
           case tail.CONNECTING:
-            await setTimeout(1000);
+            await setTimeout(100);
             break;
           case tail.CLOSING:
-            await setTimeout(1000);
+            await setTimeout(100);
             break;
           case tail.CLOSED:
-            process.exit(1);
+            throw new Error(
+              `Connection to ${scriptDisplayName} closed unexpectedly.`
+            );
         }
       }
 
-      console.log(`Connected to ${scriptName}, waiting for logs...`);
+      console.log(`Connected to ${scriptDisplayName}, waiting for logs...`);
+
+      tail.on("close", async () => {
+        tail.terminate();
+        await deleteTail();
+      });
     }
   );
 
@@ -801,14 +1130,12 @@ export async function main(argv: string[]): Promise<void> {
     (yargs) => {
       return yargs
         .positional("method", {
+          type: "string",
           describe: "Type of request to preview your worker",
-          choices: ["GET", "POST"],
-          default: ["GET"],
         })
         .positional("body", {
           type: "string",
           describe: "Body string to post to your preview worker request.",
-          default: "Null",
         })
         .option("env", {
           type: "string",
@@ -820,11 +1147,104 @@ export async function main(argv: string[]): Promise<void> {
           type: "boolean",
         });
     },
-    () => {
-      // "🔬 [DEPRECATED] Preview your code temporarily on https://cloudflareworkers.com"
-      throw new DeprecationError(
-        "`wrangler preview` has been deprecated, please refer to TODO://some/path for alternatives"
+    async (args) => {
+      if (args.method || args.body) {
+        throw new DeprecationError(
+          "The `wrangler preview` command has been deprecated.\n" +
+            "Try using `wrangler dev` to to try out a worker during development.\n"
+        );
+      }
+
+      // Delegate to `wrangler dev`
+      console.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 entry = getEntry(config, "dev");
+
+      // -- snip, extract --
+      const loggedIn = await loginOrRefreshIfRequired();
+      if (!loggedIn) {
+        // didn't login, let's just quit
+        console.log("Did not login, quitting...");
+        return;
+      }
+
+      if (!config.account_id) {
+        config.account_id = await getAccountId();
+        if (!config.account_id) {
+          throw new Error("No account id found, quitting...");
+        }
+      }
+      // -- snip, end --
+
+      const environments = config.env ?? {};
+      const envRootObj = args.env ? environments[args.env] || {} : config;
+
+      const { waitUntilExit } = render(
+        <Dev
+          name={config.name}
+          entry={entry}
+          rules={getRules(config)}
+          env={args.env}
+          zone={undefined}
+          legacyEnv={isLegacyEnv(args, config)}
+          buildCommand={config.build || {}}
+          format={config.build?.upload?.format}
+          initialMode={args.local ? "local" : "remote"}
+          jsxFactory={envRootObj?.jsx_factory}
+          jsxFragment={envRootObj?.jsx_fragment}
+          enableLocalPersistence={false}
+          accountId={config.account_id}
+          assetPaths={undefined}
+          port={config.dev?.port}
+          public={undefined}
+          compatibilityDate={
+            config.compatibility_date ||
+            new Date().toISOString().substring(0, 10)
+          }
+          compatibilityFlags={
+            (args["compatibility-flags"] as string[]) ||
+            config.compatibility_flags
+          }
+          usageModel={config.usage_model}
+          bindings={{
+            kv_namespaces: envRootObj.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
+                // break production data. So here we check that a `preview_id`
+                // has actually been configured.
+                // This whole block of code will be obsoleted in the future
+                // when we have copy-on-write for previews on edge workers.
+                if (!preview_id) {
+                  // TODO: This error has to be a _lot_ better, ideally just asking
+                  // to create a preview namespace for the user automatically
+                  throw new Error(
+                    `In development, you should use a separate kv namespace than the one you'd use in production. Please create a new kv namespace with "wrangler kv:namespace create <name> --preview" and add its id as preview_id to the kv_namespace "${binding}" in your wrangler.toml`
+                  ); // Ugh, I really don't like this message very much
+                }
+                return {
+                  binding,
+                  id: preview_id,
+                };
+              }
+            ),
+            vars: envRootObj.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,
+          }}
+          inspectorPort={await getPort({ port: 9229 })}
+        />
+      );
+      await waitUntilExit();
     }
   );
 
@@ -837,7 +1257,7 @@ export async function main(argv: string[]): Promise<void> {
       return routeYargs
         .command(
           "list",
-          "List a route associated with a zone",
+          "List the routes associated with a zone",
           (yargs) => {
             return yargs
               .option("env", {
@@ -846,17 +1266,19 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("zone", {
                 type: "string",
-                describe: "zone id",
+                describe: "Zone id",
               })
               .positional("zone", {
-                describe: "zone id",
+                describe: "Zone id",
                 type: "string",
               });
           },
           async (args) => {
             console.log(":route list", args);
             // TODO: use environment (current wrangler doesn't do so?)
-            const zone = args.zone || (args.config as Config).zone_id;
+            // TODO: don't get `zone_id` from config at all and require the command line arg `--zone`.
+            const config = readConfig(args.config as ConfigPath);
+            const zone = args.zone || config.zone_id;
             if (!zone) {
               throw new Error("missing zone id");
             }
@@ -885,7 +1307,8 @@ export async function main(argv: string[]): Promise<void> {
           async (args) => {
             console.log(":route delete", args);
             // TODO: use environment (current wrangler doesn't do so?)
-            const zone = args.zone || (args.config as Config).zone_id;
+            const config = readConfig(args.config as ConfigPath);
+            const zone = args.zone || config.zone_id;
             if (!zone) {
               throw new Error("missing zone id");
             }
@@ -927,82 +1350,86 @@ export async function main(argv: string[]): Promise<void> {
           (yargs) => {
             return yargs
               .positional("key", {
-                describe: "The variable name to be accessible in the script.",
+                describe: "The variable name to be accessible in the script",
                 type: "string",
               })
               .option("name", {
-                describe: "name of the script",
+                describe: "Name of the worker",
                 type: "string",
               })
               .option("env", {
                 type: "string",
                 describe:
-                  "Binds the secret to the script of the specific environment.",
+                  "Binds the secret to the Worker of the specific environment",
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                "--local not implemented for this command yet"
-              );
-            }
-            const config = args.config as Config;
+            const config = readConfig(args.config as ConfigPath);
 
-            // TODO: use environment (how does current wrangler do it?)
-            const scriptName = args.name || config.name;
+            const scriptName = getScriptName(args, config);
             if (!scriptName) {
               throw new Error("Missing script name");
             }
 
             // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
+              return;
+            }
 
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
             const secretValue = await prompt(
               "Enter a secret value:",
               "password"
             );
+
+            console.log(
+              `🌀 Creating the secret for script ${scriptName} ${
+                args.env && !isLegacyEnv(args, config) ? `(${args.env})` : ""
+              }`
+            );
+
             async function submitSecret() {
-              return await fetchResult(
-                `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets/`,
-                {
-                  method: "PUT",
-                  headers: { "Content-Type": "application/json" },
-                  body: JSON.stringify({
-                    name: args.key,
-                    text: secretValue,
-                    type: "secret_text",
-                  }),
-                }
-              );
+              const url =
+                !args.env || isLegacyEnv(args, config)
+                  ? `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
+                  : `/accounts/${config.account_id}/workers/services/${scriptName}/environments/${args.env}/secrets`;
+
+              return await fetchResult(url, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  name: args.key,
+                  text: secretValue,
+                  type: "secret_text",
+                }),
+              });
             }
 
             try {
-              console.log(await submitSecret());
+              await submitSecret();
             } catch (e) {
+              // @ts-expect-error non-standard property on Error
               if (e.code === 10007) {
                 // upload a draft worker
+                // TODO: log a warning
                 await fetchResult(
-                  `/accounts/${config.account_id}/workers/scripts/${scriptName}`,
+                  !args["legacy-env"] && args.env
+                    ? `/accounts/${config.account_id}/workers/services/${scriptName}/environments/${args.env}`
+                    : `/accounts/${config.account_id}/workers/scripts/${scriptName}`,
                   {
                     method: "PUT",
-                    // @ts-expect-error TODO: fix this error!
                     body: toFormData({
+                      name: scriptName,
                       main: {
                         name: scriptName,
                         content: `export default { fetch() {} }`,
@@ -1012,17 +1439,26 @@ export async function main(argv: string[]): Promise<void> {
                         kv_namespaces: [],
                         vars: {},
                         durable_objects: { bindings: [] },
+                        r2_buckets: [],
+                        wasm_modules: {},
+                        text_blobs: {},
+                        unsafe: [],
                       },
                       modules: [],
+                      migrations: undefined,
+                      compatibility_date: undefined,
+                      compatibility_flags: undefined,
+                      usage_model: undefined,
                     }),
                   }
                 );
 
                 // and then try again
-                console.log(await submitSecret());
+                await submitSecret();
                 // TODO: delete the draft worker if this failed too?
               }
             }
+            console.log(`✨ Success! Uploaded secret ${args.key}`);
           }
         )
         .command(
@@ -1031,63 +1467,65 @@ export async function main(argv: string[]): Promise<void> {
           (yargs) => {
             return yargs
               .positional("key", {
-                describe: "The variable name to be accessible in the script.",
+                describe: "The variable name to be accessible in the script",
                 type: "string",
               })
               .option("name", {
-                describe: "name of the script",
+                describe: "Name of the worker",
                 type: "string",
               })
               .option("env", {
                 type: "string",
                 describe:
-                  "Binds the secret to the script of the specific environment.",
+                  "Binds the secret to the Worker of the specific environment",
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                "--local not implemented for this command yet"
-              );
-            }
-            const config = args.config as Config;
+            const config = readConfig(args.config as ConfigPath);
 
-            // TODO: use environment (how does current wrangler do it?)
-            const scriptName = args.name || config.name;
+            const scriptName = getScriptName(args, config);
             if (!scriptName) {
               throw new Error("Missing script name");
             }
 
             // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
+              return;
+            }
 
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
-            if (await confirm("Are you sure you want to delete this secret?")) {
+            if (
+              await confirm(
+                `Are you sure you want to permanently delete the variable ${
+                  args.key
+                } on the script ${scriptName}${
+                  args.env && !isLegacyEnv(args, config) ? ` (${args.env})` : ""
+                }?`
+              )
+            ) {
               console.log(
-                `Deleting the secret ${args.key} on script ${scriptName}.`
+                `🌀 Deleting the secret ${args.key} on script ${scriptName}${
+                  args.env && !isLegacyEnv(args, config) ? ` (${args.env})` : ""
+                }`
               );
 
-              console.log(
-                await fetchResult(
-                  `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets/${args.key}`,
-                  { method: "DELETE" }
-                )
-              );
+              const url =
+                !args.env || isLegacyEnv(args, config)
+                  ? `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
+                  : `/accounts/${config.account_id}/workers/services/${scriptName}/environments/${args.env}/secrets`;
+
+              await fetchResult(`${url}/${args.key}`, { method: "DELETE" });
+              console.log(`✨ Success! Deleted secret ${args.key}`);
             }
           }
         )
@@ -1097,53 +1535,45 @@ export async function main(argv: string[]): Promise<void> {
           (yargs) => {
             return yargs
               .option("name", {
-                describe: "name of the script",
+                describe: "Name of the worker",
                 type: "string",
               })
               .option("env", {
                 type: "string",
                 describe:
-                  "Binds the secret to the script of the specific environment.",
+                  "Binds the secret to the Worker of the specific environment.",
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                "--local not implemented for this command yet"
-              );
-            }
-            const config = args.config as Config;
+            const config = readConfig(args.config as ConfigPath);
 
-            // TODO: use environment (how does current wrangler do it?)
-            const scriptName = args.name || config.name;
+            const scriptName = getScriptName(args, config);
             if (!scriptName) {
               throw new Error("Missing script name");
             }
 
             // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
+              return;
+            }
 
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
-            console.log(
-              await fetchResult(
-                `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
-              )
-            );
+            const url =
+              !args.env || isLegacyEnv(args, config)
+                ? `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
+                : `/accounts/${config.account_id}/workers/services/${scriptName}/environments/${args.env}/secrets`;
+
+            console.log(JSON.stringify(await fetchResult(url), null, "  "));
           }
         );
     }
@@ -1164,6 +1594,7 @@ export async function main(argv: string[]): Promise<void> {
               .positional("namespace", {
                 describe: "The name of the new namespace",
                 type: "string",
+                demandOption: true,
               })
               .option("env", {
                 type: "string",
@@ -1188,7 +1619,7 @@ export async function main(argv: string[]): Promise<void> {
               );
             }
 
-            const config = args.config as Config;
+            const config = readConfig(args.config as ConfigPath);
             if (!config.name) {
               console.warn(
                 "No configured name present, using `worker` as a prefix for the title"
@@ -1200,35 +1631,20 @@ export async function main(argv: string[]): Promise<void> {
             const preview = args.preview ? "_preview" : "";
             const title = `${name}${environment}-${args.namespace}${preview}`;
 
-            if (args.local) {
-              const { Miniflare } = await import("miniflare");
-              const mf = new Miniflare({
-                kvPersist: (args.kvPersist as string) || true,
-                // TODO: these options shouldn't be required
-                script: ` `, // has to be a string with at least one char
-              });
-              await mf.getKVNamespace(title); // this should "create" the namespace
-              console.log(`✨ Success! Created KV namespace ${title}`);
+            // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
               return;
             }
 
-            // -- snip, extract --
-
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
             // TODO: generate a binding name stripping non alphanumeric chars
@@ -1254,31 +1670,22 @@ export async function main(argv: string[]): Promise<void> {
           "Outputs a list of all KV namespaces associated with your account id.",
           {},
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                `local mode is not yet supported for this command`
-              );
-            }
-
-            const config = args.config as Config;
+            const config = readConfig(args.config as ConfigPath);
 
             // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
+              return;
+            }
 
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
             // TODO: we should show bindings if they exist for given ids
@@ -1316,40 +1723,31 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                `local mode is not yet supported for this command`
-              );
-            }
-            const config = args.config as Config;
+            const config = readConfig(args.config as ConfigPath);
 
             let id;
             try {
-              id = getNamespaceId(args);
+              id = getNamespaceId(args, config);
             } catch (e) {
               throw new CommandLineArgsError(
-                "Not able to delete namespace.\n" + e.message
+                "Not able to delete namespace.\n" + ((e as Error).message ?? e)
               );
             }
 
             // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
+              return;
+            }
 
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
-
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
             await fetchResult<{ id: string }>(
@@ -1392,19 +1790,20 @@ export async function main(argv: string[]): Promise<void> {
             return yargs
               .positional("key", {
                 type: "string",
-                describe: "The key to write to.",
+                describe: "The key to write to",
+                demandOption: true,
               })
               .positional("value", {
                 type: "string",
-                describe: "The value to write.",
+                describe: "The value to write",
               })
               .option("binding", {
                 type: "string",
-                describe: "The binding of the namespace to write to.",
+                describe: "The binding of the namespace to write to",
               })
               .option("namespace-id", {
                 type: "string",
-                describe: "The id of the namespace to write to.",
+                describe: "The id of the namespace to write to",
               })
               .check(demandOneOfOption("binding", "namespace-id"))
               .option("env", {
@@ -1417,7 +1816,7 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("ttl", {
                 type: "number",
-                describe: "Time for which the entries should be visible.",
+                describe: "Time for which the entries should be visible",
               })
               .option("expiration", {
                 type: "number",
@@ -1426,16 +1825,18 @@ export async function main(argv: string[]): Promise<void> {
               })
               .option("path", {
                 type: "string",
-                describe: "Read value from the file at a given path.",
+                describe: "Read value from the file at a given path",
               })
               .check(demandOneOfOption("value", "path"));
           },
           async ({ key, ttl, expiration, ...args }) => {
-            const namespaceId = getNamespaceId(args);
+            const config = readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, config);
+            // One of `args.path` and `args.value` must be defined
             const value = args.path
-              ? await readFile(args.path, "utf-8")
-              : args.value;
-            const config = args.config as Config;
+              ? readFileSync(args.path)
+              : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                args.value!;
 
             if (args.path) {
               console.log(
@@ -1447,35 +1848,20 @@ export async function main(argv: string[]): Promise<void> {
               );
             }
 
-            if (args.local) {
-              const { Miniflare } = await import("miniflare");
-              const mf = new Miniflare({
-                kvPersist: (args.kvPersist as string) || true,
-                // TODO: these options shouldn't be required
-                script: ` `, // has to be a string with at least one char
-              });
-              const ns = await mf.getKVNamespace(namespaceId);
-              await ns.put(key, value, { expiration, expirationTtl: ttl });
+            // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
               return;
             }
-            // -- snip, extract --
-
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
 
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
             await putKeyValue(config.account_id, namespaceId, key, value, {
@@ -1515,46 +1901,31 @@ export async function main(argv: string[]): Promise<void> {
           },
           async ({ prefix, ...args }) => {
             // TODO: support for limit+cursor (pagination)
+            const config = readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, config);
 
-            const namespaceId = getNamespaceId(args);
-            const config = args.config as Config;
-
-            if (args.local) {
-              const { Miniflare } = await import("miniflare");
-              const mf = new Miniflare({
-                kvPersist: (args.kvPersist as string) || true,
-                // TODO: these options shouldn't be required
-                script: ` `, // has to be a string with at least one char
-              });
-              const ns = await mf.getKVNamespace(namespaceId);
-              const listResponse = await ns.list({ prefix });
-              console.log(JSON.stringify(listResponse.keys, null, "  ")); // TODO: paginate, collate
+            // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
               return;
             }
 
-            // -- snip, extract --
-
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
-
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
-            console.log(
-              await listNamespaceKeys(config.account_id, namespaceId, prefix)
+            const results = await listNamespaceKeys(
+              config.account_id,
+              namespaceId,
+              prefix
             );
+            console.log(JSON.stringify(results, undefined, 2));
           }
         )
         .command(
@@ -1565,6 +1936,7 @@ export async function main(argv: string[]): Promise<void> {
               .positional("key", {
                 describe: "The key value to get.",
                 type: "string",
+                demandOption: true,
               })
               .option("binding", {
                 type: "string",
@@ -1591,46 +1963,26 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ key, ...args }) => {
-            const namespaceId = getNamespaceId(args);
-            const config = args.config as Config;
-
-            if (args.local) {
-              const { Miniflare } = await import("miniflare");
-              const mf = new Miniflare({
-                kvPersist: (args.kvPersist as string) || true,
-                // TODO: these options shouldn't be required
-                script: ` `, // has to be a string with at least one char
-              });
-              const ns = await mf.getKVNamespace(namespaceId);
-              console.log(await ns.get(key));
-              return;
-            }
+            const config = readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, config);
 
             // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
+              return;
+            }
 
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
-
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
-            console.log(
-              await fetchRaw(
-                `/accounts/${config.account_id}/storage/kv/namespaces/${namespaceId}/values/${key}`
-              )
-            );
+            console.log(await getKeyValue(config.account_id, namespaceId, key));
           }
         )
         .command(
@@ -1641,6 +1993,7 @@ export async function main(argv: string[]): Promise<void> {
               .positional("key", {
                 describe: "The key value to delete",
                 type: "string",
+                demandOption: true,
               })
               .option("binding", {
                 type: "string",
@@ -1661,44 +2014,27 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ key, ...args }) => {
-            const namespaceId = getNamespaceId(args);
+            const config = readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, config);
 
             console.log(
               `deleting the key "${key}" on namespace ${namespaceId}`
             );
 
-            if (args.local) {
-              const { Miniflare } = await import("miniflare");
-              const mf = new Miniflare({
-                kvPersist: (args.kvPersist as string) || true,
-                // TODO: these options shouldn't be required
-                script: ` `, // has to be a string with at least one char
-              });
-              const ns = await mf.getKVNamespace(namespaceId);
-              console.log(await ns.delete(key));
+            // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
               return;
             }
 
-            const config = args.config as Config;
-
-            // -- snip, extract --
-
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
-
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
             await fetchResult(
@@ -1724,14 +2060,15 @@ export async function main(argv: string[]): Promise<void> {
               .positional("filename", {
                 describe: `The JSON file of key-value pairs to upload, in form [{"key":..., "value":...}"...]`,
                 type: "string",
+                demandOption: true,
               })
               .option("binding", {
                 type: "string",
-                describe: "The name of the namespace to put to",
+                describe: "The name of the namespace to insert values into",
               })
               .option("namespace-id", {
                 type: "string",
-                describe: "The id of the namespace to put to",
+                describe: "The id of the namespace to insert values into",
               })
               .check(demandOneOfOption("binding", "namespace-id"))
               .option("env", {
@@ -1748,59 +2085,24 @@ export async function main(argv: string[]): Promise<void> {
             // This could be made more efficient with a streaming parser/uploader
             // but we'll do that in the future if needed.
 
-            const namespaceId = getNamespaceId(args);
-            const config = args.config as Config;
-            const content = await readFile(filename, "utf-8");
-            let parsedContent;
-            try {
-              parsedContent = JSON.parse(content);
-            } catch (err) {
-              throw new Error(
-                `Could not parse json from ${filename}.\n${err.message ?? err}`
-              );
-            }
-
-            if (args.local) {
-              const { Miniflare } = await import("miniflare");
-              const mf = new Miniflare({
-                kvPersist: (args.kvPersist as string) || true,
-                // TODO: these options shouldn't be required
-                script: ` `, // has to be a string with at least one char
-              });
-              const ns = await mf.getKVNamespace(namespaceId);
-              for (const {
-                key,
-                value,
-                expiration,
-                expiration_ttl,
-              } of parsedContent) {
-                await ns.put(key, value, {
-                  expiration,
-                  expirationTtl: expiration_ttl,
-                });
-              }
+            const config = readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, config);
+            const content = parseJSON(readFileSync(filename), filename);
 
+            // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
               return;
             }
 
-            // -- snip, extract --
-
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
-
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
             console.log(
@@ -1810,12 +2112,13 @@ export async function main(argv: string[]): Promise<void> {
         )
         .command(
           "delete <filename>",
-          "Upload multiple key-value pairs to a namespace",
+          "Delete multiple key-value pairs from a namespace",
           (yargs) => {
             return yargs
               .positional("filename", {
-                describe: `The JSON file of key-value pairs to upload, in form ["key1", "key2", ...]`,
+                describe: `The JSON file of keys to delete, in the form ["key1", "key2", ...]`,
                 type: "string",
+                demandOption: true,
               })
               .option("binding", {
                 type: "string",
@@ -1836,51 +2139,24 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ filename, ...args }) => {
-            const namespaceId = getNamespaceId(args);
-            const config = args.config as Config;
-            const content = await readFile(filename, "utf-8");
-            let parsedContent;
-            try {
-              parsedContent = JSON.parse(content);
-            } catch (err) {
-              throw new Error(
-                `Could not parse json from ${filename}.\n${err.message ?? err}`
-              );
-            }
-
-            if (args.local) {
-              const { Miniflare } = await import("miniflare");
-              const mf = new Miniflare({
-                kvPersist: (args.kvPersist as string) || true,
-                // TODO: these options shouldn't be required
-                script: ` `, // has to be a string with at least one char
-              });
-              const ns = await mf.getKVNamespace(namespaceId);
-              for (const key of parsedContent) {
-                await ns.delete(key);
-              }
+            const config = readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, config);
+            const content = parseJSON(readFileSync(filename), filename);
 
+            // -- snip, extract --
+            const loggedIn = await loginOrRefreshIfRequired();
+            if (!loggedIn) {
+              // didn't login, let's just quit
+              console.log("Did not login, quitting...");
               return;
             }
 
-            // -- snip, extract --
-
-            if (!args.local) {
-              const loggedIn = await loginOrRefreshIfRequired();
-              if (!loggedIn) {
-                // didn't login, let's just quit
-                console.log("Did not login, quitting...");
-                return;
-              }
-
+            if (!config.account_id) {
+              config.account_id = await getAccountId();
               if (!config.account_id) {
-                config.account_id = await getAccountId();
-                if (!config.account_id) {
-                  throw new Error("No account id found, quitting...");
-                }
+                throw new Error("No account id found, quitting...");
               }
             }
-
             // -- snip, end --
 
             console.log(
@@ -1893,37 +2169,159 @@ export async function main(argv: string[]): Promise<void> {
 
   wrangler.command("pages", "⚡️ Configure Cloudflare Pages", pages);
 
+  wrangler.command("r2", "📦 Interact with an R2 store", (r2Yargs) => {
+    return r2Yargs.command("bucket", "Manage R2 buckets", (r2BucketYargs) => {
+      r2BucketYargs.command(
+        "create <name>",
+        "Create a new R2 bucket",
+        (yargs) => {
+          return yargs.positional("name", {
+            describe: "The name of the new bucket",
+            type: "string",
+            demandOption: true,
+          });
+        },
+        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}".`
+            );
+          }
+
+          const config = readConfig(args.config as ConfigPath);
+
+          // -- snip, extract --
+          const loggedIn = await loginOrRefreshIfRequired();
+          if (!loggedIn) {
+            // didn't login, let's just quit
+            console.log("Did not login, quitting...");
+            return;
+          }
+
+          if (!config.account_id) {
+            config.account_id = await getAccountId();
+            if (!config.account_id) {
+              throw new Error("No account id found, quitting...");
+            }
+          }
+          // -- snip, end --
+
+          console.log(`Creating bucket ${args.name}.`);
+          await createR2Bucket(config.account_id, args.name);
+          console.log(`Created bucket ${args.name}.`);
+        }
+      );
+
+      r2BucketYargs.command("list", "List R2 buckets", {}, async (args) => {
+        const config = readConfig(args.config as ConfigPath);
+
+        // -- snip, extract --
+        const loggedIn = await loginOrRefreshIfRequired();
+        if (!loggedIn) {
+          // didn't login, let's just quit
+          console.log("Did not login, quitting...");
+          return;
+        }
+
+        if (!config.account_id) {
+          config.account_id = await getAccountId();
+          if (!config.account_id) {
+            throw new Error("No account id found, quitting...");
+          }
+        }
+        // -- snip, end --
+
+        console.log(
+          JSON.stringify(await listR2Buckets(config.account_id), null, 2)
+        );
+      });
+
+      r2BucketYargs.command(
+        "delete <name>",
+        "Delete an R2 bucket",
+        (yargs) => {
+          return yargs.positional("name", {
+            describe: "The name of the bucket to delete",
+            type: "string",
+            demandOption: true,
+          });
+        },
+        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}".`
+            );
+          }
+
+          const config = readConfig(args.config as ConfigPath);
+
+          // -- snip, extract --
+          const loggedIn = await loginOrRefreshIfRequired();
+          if (!loggedIn) {
+            // didn't login, let's just quit
+            console.log("Did not login, quitting...");
+            return;
+          }
+
+          if (!config.account_id) {
+            config.account_id = await getAccountId();
+            if (!config.account_id) {
+              throw new Error("No account id found, quitting...");
+            }
+          }
+          // -- snip, end --
+
+          console.log(`Deleting bucket ${args.name}.`);
+          await deleteR2Bucket(config.account_id, args.name);
+          console.log(`Deleted bucket ${args.name}.`);
+        }
+      );
+      return r2BucketYargs;
+    });
+  });
+
   wrangler
+    .option("legacy-env", {
+      type: "boolean",
+      describe: "Use legacy environments",
+    })
     .option("config", {
       alias: "c",
       describe: "Path to .toml configuration file",
       type: "string",
-      async coerce(arg) {
-        return await readConfig(arg);
-      },
-    })
-    .option("local", {
-      alias: "l",
-      describe: "Run on my machine",
-      type: "boolean",
-      default: false, // I bet this will a point of contention. We'll revisit it.
     });
 
-  wrangler.group(["config", "help", "version"], "Flags:");
+  wrangler.group(["config", "help", "version", "legacy-env"], "Flags:");
   wrangler.help().alias("h", "help");
   wrangler.version(wranglerVersion).alias("v", "version");
   wrangler.exitProcess(false);
 
-  await initialiseUserConfig();
-
   try {
+    await initialiseUserConfig();
     await wrangler.parse();
   } catch (e) {
     if (e instanceof CommandLineArgsError) {
       wrangler.showHelp("error");
       console.error(""); // Just adds a bit of space
+      console.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));
+    } else {
+      console.error(e instanceof Error ? e.message : e);
+      console.error(""); // Just adds a bit of space
+      console.error(
+        `${fgGreenColor}%s${resetColor}`,
+        "If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      );
     }
-    console.error(e.message);
     throw e;
   }
 }