wrangler 0.0.0-e14e589 → 0.0.0-e2a26a0

package/src/index.tsx

@@ -1,23 +1,19 @@
-import React from "react";
+import * as fs from "node:fs";
+import { readFile, 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 { 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 { hideBin } from "yargs/helpers";
-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 { normaliseAndValidateEnvironmentsConfig } from "./config";
+import Dev from "./dev";
+import { confirm, prompt } from "./dialogs";
 import {
   getNamespaceId,
   listNamespaces,
@@ -25,41 +21,58 @@ import {
   putKeyValue,
   putBulkKeyValue,
   deleteBulkKeyValue,
+  createNamespace,
+  isValidNamespaceBinding,
+  getKeyValue,
 } from "./kv";
-
+import { getPackageManager } from "./package-manager";
 import { pages } from "./pages";
-
-import cfetch from "./cfetch";
-
 import publish from "./publish";
-import path from "path/posix";
-import { writeFile } from "node:fs/promises";
-import { toFormData } from "./api/form_data";
-
+import { getAssetPaths } from "./sites";
 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 {
+  login,
+  logout,
+  listScopes,
+  initialise as initialiseUserConfig,
+  loginOrRefreshIfRequired,
+  getAccountId,
+  validateScopeKeys,
+} from "./user";
+import { whoami } from "./whoami";
+
+import type { Config } from "./config";
+import type Yargs from "yargs";
 
-async function readConfig(path?: string): Promise<Config> {
+const resetColor = "\x1b[0m";
+const fgGreenColor = "\x1b[32m";
+
+async function readConfig(configPath?: string): Promise<Config> {
   const config: Config = {};
-  if (!path) {
-    path = await findUp("wrangler.toml");
+  if (!configPath) {
+    configPath = await findUp("wrangler.toml");
     // TODO - terminate this early instead of going all the way to the root
   }
 
-  if (path) {
-    const tml: string = await readFile(path, "utf-8");
+  if (configPath) {
+    const tml: string = await readFile(configPath, "utf-8");
     const parsed = TOML.parse(tml) as Config;
     Object.assign(config, parsed);
   }
 
+  normaliseAndValidateEnvironmentsConfig(config);
+
+  if ("experimental_services" in config) {
+    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"
+    );
+  }
+
   // todo: validate, add defaults
   // let's just do some basics for now
 
   // @ts-expect-error we're being sneaky here for now
-  config.__path__ = path;
+  config.__path__ = configPath;
 
   return config;
 }
@@ -67,18 +80,18 @@ async function readConfig(path?: string): Promise<Config> {
 // a helper to demand one of a set of options
 // via https://github.com/yargs/yargs/issues/1093#issuecomment-491299261
 function demandOneOfOption(...options: string[]) {
-  return function (argv: yargs.Arguments) {
+  return function (argv: Yargs.Arguments) {
     const count = options.filter((option) => argv[option]).length;
     const lastOption = options.pop();
 
     if (count === 0) {
-      throw new Error(
+      throw new CommandLineArgsError(
         `Exactly one of the arguments ${options.join(
           ", "
         )} and ${lastOption} is required`
       );
     } else if (count > 1) {
-      throw new Error(
+      throw new CommandLineArgsError(
         `Arguments ${options.join(
           ", "
         )} and ${lastOption} are mutually exclusive`
@@ -89,30 +102,49 @@ function demandOneOfOption(...options: string[]) {
   };
 }
 
+class CommandLineArgsError extends Error {}
+class DeprecationError extends Error {}
+class NotImplementedError extends Error {}
+
 export async function main(argv: string[]): Promise<void> {
-  const yargs = makeCLI(hideBin(process.argv))
-    .command(
-      // the default is to simply print the help menu
-      ["*"],
-      false,
-      () => {},
-      () => {
-        yargs.showHelp("log");
+  const wrangler = makeCLI(argv)
+    // 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`.
+        error = new CommandLineArgsError(msg);
       }
-    )
+      throw error;
+    })
     .scriptName("wrangler")
     .wrap(null);
 
-  // you will note that we use the form for all commands where we use the builder function
-  // to define options and subcommands. Further we return the result of this builder even
-  // tho it's not completely necessary. The reason is that it's required for type inference
-  // of the args in the handle function.I wish we could enforce this pattern, but this
-  // comment will have to do for now.
+  // the default is to simply print the help menu
+  wrangler.command(
+    ["*"],
+    false,
+    () => {},
+    (args) => {
+      if (args._.length > 0) {
+        throw new CommandLineArgsError(`Unknown command: ${args._}.`);
+      } else {
+        wrangler.showHelp("log");
+      }
+    }
+  );
 
-  // also annoying that choices[] doesn't get inferred as an enum. bleh.
+  // You will note that we use the form for all commands where we use the builder function
+  // to define options and subcommands.
+  // Further we return the result of this builder even though it's not completely necessary.
+  // The reason is that it's required for type inference of the args in the handle function.
+  // I wish we could enforce this pattern, but this comment will have to do for now.
+  // (It's also annoying that choices[] doesn't get inferred as an enum. 🤷‍♂.)
 
   // [DEPRECATED] generate
-  yargs.command(
+  wrangler.command(
     // we definitely want to move away from us cloning github templates
     // we can do something better here, let's see
     "generate [name] [template]",
@@ -130,14 +162,14 @@ export async function main(argv: string[]): Promise<void> {
     },
     () => {
       // "👯 [DEPRECATED]. Scaffold a Cloudflare Workers project from a public GitHub repository.",
-      console.error(
+      throw new DeprecationError(
         "`wrangler generate` has been deprecated, please refer to TODO://some/path for alternatives"
       );
     }
   );
 
   // init
-  yargs.command(
+  wrangler.command(
     "init [name]",
     "📥 Create a wrangler.toml configuration file",
     (yargs) => {
@@ -146,66 +178,115 @@ export async function main(argv: string[]): Promise<void> {
         type: "string",
       });
     },
-    async () => {
-      const destination = path.join(process.cwd(), "wrangler.toml");
+    async (args) => {
+      if ("type" in args) {
+        let message = "The --type option is no longer supported.";
+        if (args.type === "webpack") {
+          message +=
+            "\nIf you wish to use webpack then you will need to create a custom build.";
+          // TODO: Add a link to docs
+        }
+        throw new CommandLineArgsError(message);
+      }
+
+      const packageManager = await getPackageManager(process.cwd());
+
+      const destination = "./wrangler.toml";
       if (fs.existsSync(destination)) {
-        console.error(`${destination} already exists.`);
+        console.warn(`${destination} file already exists!`);
+        const shouldContinue = await confirm(
+          "Do you want to continue initializing this project?"
+        );
+        if (!shouldContinue) {
+          return;
+        }
       } else {
         const compatibilityDate = new Date().toISOString().substring(0, 10);
         try {
           await writeFile(
             destination,
-            `compatibility_date = "${compatibilityDate}"
-  `
+            `compatibility_date = "${compatibilityDate}"` + "\n"
           );
-          console.log(`✨ Succesfully created wrangler.toml`);
+          console.log(`✨ Successfully created wrangler.toml`);
           // TODO: suggest next steps?
         } catch (err) {
-          console.error(`Failed to create wrangler.toml`);
-          console.error(err);
-          throw 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");
-
       if (!pathToPackageJson) {
-        if (
-          await confirm("No package.json found. Would you like to create one?")
-        ) {
+        // If no package.json exists, ask to create one
+        const shouldCreatePackageJson = await confirm(
+          "No package.json found. Would you like to create one?"
+        );
+        if (shouldCreatePackageJson) {
           await writeFile(
-            path.join(process.cwd(), "package.json"),
+            "./package.json",
             JSON.stringify(
               {
                 name: "worker",
-                version: "0.0.1",
+                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");
         } else {
           return;
         }
+      } else {
+        // If package.json exists and wrangler isn't installed,
+        // then ask to add wrangler to devDependencies
+        const packageJson = JSON.parse(
+          await readFile(pathToPackageJson, "utf-8")
+        );
+        if (
+          !(
+            packageJson.devDependencies?.wrangler ||
+            packageJson.dependencies?.wrangler
+          )
+        ) {
+          const shouldInstall = 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 (await confirm("Would you like to use TypeScript?")) {
+          isTypescriptProject = true;
           await writeFile(
-            path.join(process.cwd(), "tsconfig.json"),
+            "./tsconfig.json",
             JSON.stringify(
               {
                 compilerOptions: {
-                  target: "ES2020",
-                  module: "CommonJS",
-                  lib: ["ES2020"],
+                  target: "es2021",
+                  module: "es2022",
+                  moduleResolution: "node",
+                  allowJs: true,
+                  allowSyntheticDefaultImports: true,
+                  isolatedModules: true,
+                  noEmit: true,
+                  lib: ["es2021"],
+                  resolveJsonModule: true,
                   types: ["@cloudflare/workers-types"],
                 },
               },
@@ -213,22 +294,85 @@ export async function main(argv: string[]): Promise<void> {
               "  "
             ) + "\n"
           );
-          await execa("npm", [
-            "install",
+          await packageManager.addDevDeps(
             "@cloudflare/workers-types",
-            "--save-dev",
-          ]);
+            "typescript"
+          );
+
           console.log(
             `✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies`
           );
           pathToTSConfig = path.join(process.cwd(), "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 = JSON.parse(
+          await readFile(pathToPackageJson, "utf-8")
+        );
+        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`
+            );
+          }
+        }
+      }
+
+      if (isTypescriptProject) {
+        if (!fs.existsSync("./src/index.ts")) {
+          const shouldCreateSource = await confirm(
+            `Would you like to create a Worker at src/index.ts?`
+          );
+          if (shouldCreateSource) {
+            await mkdir("./src", { recursive: true });
+            await writeFile(
+              "./src/index.ts",
+              await readFile(
+                path.join(__dirname, "../templates/new-worker.ts"),
+                "utf-8"
+              )
+            );
+            console.log(`✨ Created 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("./src", { recursive: true });
+            await writeFile(
+              path.join("./src/index.js"),
+              await readFile(
+                path.join(__dirname, "../templates/new-worker.js"),
+                "utf-8"
+              )
+            );
+            console.log(`✨ Created src/index.js`);
+          }
+        }
       }
     }
   );
 
   // build
-  yargs.command(
+  wrangler.command(
     "build",
     false,
     (yargs) => {
@@ -238,14 +382,14 @@ export async function main(argv: string[]): Promise<void> {
     },
     () => {
       // "[DEPRECATED] 🦀 Build your project (if applicable)",
-      console.error(
+      throw new DeprecationError(
         "`wrangler build` has been deprecated, please refer to TODO://some/path for alternatives"
       );
     }
   );
 
   // login
-  yargs.command(
+  wrangler.command(
     // this needs scopes as an option?
     "login",
     false, // we don't need to show this in the menu
@@ -276,19 +420,24 @@ 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;
       }
       await login();
 
       // TODO: would be nice if it optionally saved login
-      // creds inside node_modules/.cache or something
+      // credentials inside node_modules/.cache or something
       // this way you could have multiple users on a single machine
     }
   );
 
   // logout
-  yargs.command(
+  wrangler.command(
     // this needs scopes as an option?
     "logout",
     false, // we don't need to show this in the menu
@@ -300,36 +449,39 @@ export async function main(argv: string[]): Promise<void> {
   );
 
   // whoami
-  yargs.command(
+  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();
     }
   );
 
   // config
-  yargs.command(
+  wrangler.command(
     "config",
     false,
     () => {},
     () => {
       // "🕵️  Authenticate Wrangler with a Cloudflare API Token",
-      console.error(
+      throw new DeprecationError(
         "`wrangler config` has been deprecated, please refer to TODO://some/path for alternatives"
       );
     }
   );
 
   // dev
-  yargs.command(
+  wrangler.command(
     "dev <filename>",
     "👂 Start a local server for developing your worker",
     (yargs) => {
       return yargs
-        .positional("filename", { describe: "entry point", type: "string" })
+        .positional("filename", {
+          describe: "entry point",
+          type: "string",
+          demandOption: true,
+        })
         .option("name", {
           describe: "name of the script",
           type: "string",
@@ -343,6 +495,20 @@ export async function main(argv: string[]): Promise<void> {
           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",
           type: "string",
@@ -356,14 +522,14 @@ export async function main(argv: string[]): Promise<void> {
         .option("host", {
           type: "string",
           describe:
-            "Host to forward requests to, defaults to the zone of project or to tutorial.cloudflareworkers.com if unauthenticated",
+            "Host to forward requests to, defaults to the zone of project",
         })
         .option("local-protocol", {
           default: "http",
           describe: "Protocol to listen to requests on, defaults to http.",
           choices: ["http", "https"],
         })
-        .option("public", {
+        .option("experimental-public", {
           describe: "Static assets to be served",
           type: "string",
         })
@@ -371,72 +537,159 @@ 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:
             "Protocol to forward requests to host on, defaults to https.",
           choices: ["http", "https"],
+        })
+        .option("jsx-factory", {
+          describe: "The function that is called for each JSX element",
+          type: "string",
+        })
+        .option("jsx-fragment", {
+          describe: "The function that is called for each JSX fragment",
+          type: "string",
+        })
+        .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;
 
-      // -- snip, extract --
+      if (args["experimental-public"]) {
+        console.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."
+        );
+      }
+
+      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) {
-            console.error("No account id found, quitting...");
-            return;
+            throw new Error("No account id found, quitting...");
           }
         }
+        // -- snip, end --
       }
 
-      // -- snip, end --
+      const environments = config.env ?? {};
+      const envRootObj = args.env ? environments[args.env] || {} : config;
 
-      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 needs 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
+      }
 
-      render(
+      const { waitUntilExit } = render(
         <Dev
           name={args.name || config.name}
-          entry={filename}
+          entry={path.relative(process.cwd(), filename)}
+          env={args.env}
+          buildCommand={config.build || {}}
           format={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}
+          assetPaths={getAssetPaths(
+            config,
+            args.site,
+            args.siteInclude,
+            args.siteExclude
+          )}
           port={args.port || config.dev?.port}
-          public={args.public}
-          variables={{
-            ...(envRootObj?.vars || {}),
-            ...(envRootObj?.kv_namespaces || []).reduce(
-              (obj, { binding, preview_id }) => {
+          public={args["experimental-public"]}
+          compatibilityDate={
+            args["compatibility-date"] ||
+            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(
-                    "kv namespaces need a preview id during dev mode"
-                  );
+                    `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 { ...obj, [binding]: { namespaceId: preview_id } };
-              },
-              {}
+                return {
+                  binding,
+                  id: preview_id,
+                };
+              }
             ),
+            vars: envRootObj.vars,
+            durable_objects: envRootObj.durable_objects,
+            services: envRootObj.experimental_services,
           }}
         />
       );
+      await waitUntilExit();
     }
   );
 
   // publish
-  yargs.command(
+  wrangler.command(
     "publish [script]",
     "🆙 Publish your Worker to Cloudflare.",
     (yargs) => {
@@ -453,7 +706,21 @@ export async function main(argv: string[]): Promise<void> {
           describe: "name to use when uploading",
           type: "string",
         })
-        .option("public", {
+        .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",
         })
@@ -461,6 +728,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("triggers", {
           describe: "cron schedules to attach",
           alias: ["schedule", "schedules"],
@@ -476,49 +755,89 @@ export async function main(argv: string[]): Promise<void> {
           type: "boolean",
           default: "false",
           hidden: true,
+        })
+        .option("jsx-factory", {
+          describe: "The function that is called for each JSX element",
+          type: "string",
+        })
+        .option("jsx-fragment", {
+          describe: "The function that is called for each JSX fragment",
+          type: "string",
         });
     },
     async (args) => {
       if (args.local) {
-        console.error("🚫  Local publishing is not yet supported");
-        return;
+        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."
+        );
+      }
+      if (args.public) {
+        throw new Error(
+          "🚨  The --public field has been renamed to --experimental-public, and will change behaviour in the future."
+        );
+      }
+
       const config = args.config as Config;
 
-      // -- snip, extract --
+      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"
+        );
+      }
+
       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) {
-            console.error("No account id found, quitting...");
-            return;
+            throw new Error("No account id found, quitting...");
           }
         }
+        // -- snip, end --
       }
 
-      // -- 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,
         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.public,
-        site: args.site,
+        assetPaths,
+        format: undefined, // TODO: add args for this
+        legacyEnv: undefined, // TODO: get this from somewhere... config?
+        experimentalPublic: args["experimental-public"] !== undefined,
       });
     }
   );
 
   // tail
-  yargs.command(
+  wrangler.command(
     "tail [name]",
     "🦚 Starts a log tailing session for a deployed Worker.",
     (yargs) => {
@@ -562,34 +881,35 @@ export async function main(argv: string[]): Promise<void> {
       // TODO: filter by client ip, which can be 'self' or an ip address
     },
     async (args) => {
+      if (args.local) {
+        throw new NotImplementedError(
+          `local mode is not yet supported for this command`
+        );
+      }
+
       const config = args.config as Config;
 
       if (!(args.name || config.name)) {
-        console.error("Missing script name");
-        return;
+        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) {
-            console.error("No account id found, quitting...");
-            return;
-          }
+          throw new Error("No account id found, quitting...");
         }
       }
-
       // -- snip, end --
 
       const accountId = config.account_id;
@@ -609,9 +929,9 @@ export async function main(argv: string[]): Promise<void> {
         `successfully created tail, expires at ${expiration.toLocaleString()}`
       );
 
-      onExit(() => {
+      onExit(async () => {
         tail.terminate();
-        deleteTail();
+        await deleteTail();
       });
 
       tail.on("message", (data) => {
@@ -636,7 +956,7 @@ export async function main(argv: string[]): Promise<void> {
   );
 
   // preview
-  yargs.command(
+  wrangler.command(
     "preview [method] [body]",
     false,
     (yargs) => {
@@ -662,20 +982,20 @@ export async function main(argv: string[]): Promise<void> {
         });
     },
     () => {
-      // "🔬 [DEPRECATED] Preview your code temporarily on cloudflareworkers.com"
-      console.error(
+      // "🔬 [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"
       );
     }
   );
 
   // route
-  yargs.command(
+  wrangler.command(
     "route",
     false, // I think we want to hide this command
     // "➡️  List or delete worker routes",
-    (yargs) => {
-      return yargs
+    (routeYargs) => {
+      return routeYargs
         .command(
           "list",
           "List a route associated with a zone",
@@ -699,11 +1019,10 @@ export async function main(argv: string[]): Promise<void> {
             // TODO: use environment (current wrangler doesn't do so?)
             const zone = args.zone || (args.config as Config).zone_id;
             if (!zone) {
-              console.error("missing zone id");
-              return;
+              throw new Error("missing zone id");
             }
 
-            console.log(await cfetch(`/zones/${zone}/workers/routes`));
+            console.log(await fetchResult(`/zones/${zone}/workers/routes`));
           }
         )
         .command(
@@ -733,7 +1052,7 @@ export async function main(argv: string[]): Promise<void> {
             }
 
             console.log(
-              await cfetch(`/zones/${zone}/workers/routes/${args.id}`, {
+              await fetchResult(`/zones/${zone}/workers/routes/${args.id}`, {
                 method: "DELETE",
               })
             );
@@ -743,7 +1062,7 @@ export async function main(argv: string[]): Promise<void> {
   );
 
   // subdomain
-  yargs.command(
+  wrangler.command(
     "subdomain [name]",
     false,
     // "👷 Create or change your workers.dev subdomain.",
@@ -751,18 +1070,18 @@ export async function main(argv: string[]): Promise<void> {
       return yargs.positional("name", { type: "string" });
     },
     () => {
-      console.error(
+      throw new DeprecationError(
         "`wrangler subdomain` has been deprecated, please refer to TODO://some/path for alternatives"
       );
     }
   );
 
   // secret
-  yargs.command(
+  wrangler.command(
     "secret",
     "🤫 Generate a secret that can be referenced in the worker script",
-    (yargs) => {
-      return yargs
+    (secretYargs) => {
+      return secretYargs
         .command(
           "put <key>",
           "Create or update a secret variable for a script",
@@ -783,45 +1102,49 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              console.error("--local not implemented for this command yet");
-              return;
-            }
             const config = args.config as Config;
 
             // TODO: use environment (how does current wrangler do it?)
             const scriptName = args.name || config.name;
             if (!scriptName) {
-              console.error("Missing script name");
-              return;
+              throw new Error("Missing script name");
             }
 
-            // -- snip, extract --
+            if (args.local) {
+              console.warn("`wrangler secret put` is a no-op in --local mode");
+            }
 
             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) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
+              // -- snip, end --
             }
 
-            // -- snip, end --
-
             const secretValue = await prompt(
               "Enter a secret value:",
               "password"
             );
+
+            if (args.local) {
+              return;
+            }
+
+            console.log(`🌀 Creating the secret for script ${scriptName}`);
+
             async function submitSecret() {
-              return await cfetch(
+              return await fetchResult(
                 `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets/`,
                 {
                   method: "PUT",
@@ -836,32 +1159,41 @@ export async function main(argv: string[]): Promise<void> {
             }
 
             try {
-              console.log(await submitSecret());
+              await submitSecret();
             } catch (e) {
               if (e.code === 10007) {
                 // upload a draft worker
-                await cfetch(
+                await fetchResult(
                   `/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() {} }`,
                         type: "esm",
                       },
-                      variables: {},
+                      bindings: {
+                        kv_namespaces: [],
+                        vars: {},
+                        durable_objects: { bindings: [] },
+                      },
                       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(
@@ -884,10 +1216,6 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              console.error("--local not implemented for this command yet");
-              return;
-            }
             const config = args.config as Config;
 
             // TODO: use environment (how does current wrangler do it?)
@@ -896,37 +1224,48 @@ export async function main(argv: string[]): Promise<void> {
               throw new Error("Missing script name");
             }
 
-            // -- snip, extract --
+            if (args.local) {
+              console.warn(
+                "`wrangler secret delete` is a no-op in --local mode"
+              );
+            }
 
             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) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
+              // -- snip, end --
             }
 
-            // -- 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}?`
+              )
+            ) {
               console.log(
-                `Deleting the secret ${args.key} on script ${scriptName}.`
+                `🌀 Deleting the secret ${args.key} on script ${scriptName}.`
               );
 
-              console.log(
-                await cfetch(
-                  `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets/${args.key}`,
-                  { method: "DELETE" }
-                )
+              if (args.local) {
+                return;
+              }
+
+              await fetchResult(
+                `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets/${args.key}`,
+                { method: "DELETE" }
               );
+              console.log(`✨ Success! Deleted secret ${args.key}`);
             }
           }
         )
@@ -946,42 +1285,47 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              console.error("--local not implemented for this command yet");
-              return;
-            }
             const config = args.config as Config;
 
             // TODO: use environment (how does current wrangler do it?)
             const scriptName = args.name || config.name;
             if (!scriptName) {
-              console.error("Missing script name");
-              return;
+              throw new Error("Missing script name");
             }
 
-            // -- snip, extract --
+            if (args.local) {
+              console.warn("`wrangler secret list` is a no-op in --local mode");
+            }
 
             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) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
+              // -- snip, end --
             }
 
-            // -- snip, end --
+            if (args.local) {
+              return;
+            }
 
             console.log(
-              await cfetch(
-                `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
+              JSON.stringify(
+                await fetchResult(
+                  `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
+                ),
+                null,
+                "  "
               )
             );
           }
@@ -991,11 +1335,11 @@ export async function main(argv: string[]): Promise<void> {
 
   // kv
   // :namespace
-  yargs.command(
+  wrangler.command(
     "kv:namespace",
     "🗂️  Interact with your Workers KV Namespaces",
-    (yargs) => {
-      return yargs
+    (namespaceYargs) => {
+      return namespaceYargs
         .command(
           "create <namespace>",
           "Create a new namespace",
@@ -1004,6 +1348,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",
@@ -1015,13 +1360,19 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args._.length !== 2) {
-              throw new Error(
-                `Did you forget to add quotes around "${
-                  args.namespace
-                } ${args._.slice(2).join(" ")}"?`
+            if (args._.length > 2) {
+              const extraArgs = args._.slice(2).join(" ");
+              throw new CommandLineArgsError(
+                `Unexpected additional positional arguments "${extraArgs}".`
               );
             }
+
+            if (!isValidNamespaceBinding(args.namespace)) {
+              throw new CommandLineArgsError(
+                `The namespace binding name "${args.namespace}" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number.`
+              );
+            }
+
             const config = args.config as Config;
             if (!config.name) {
               console.warn(
@@ -1029,13 +1380,10 @@ export async function main(argv: string[]): Promise<void> {
               );
             }
 
-            const title = `${config.name || "worker"}${
-              args.env ? `-${args.env}` : ""
-            }-${args.namespace}${args.preview ? "_preview" : ""}`;
-
-            if (/[\W]+/.test(args.namespace)) {
-              throw new Error("invalid binding name, needs to be js friendly");
-            }
+            const name = config.name || "worker";
+            const environment = args.env ? `-${args.env}` : "";
+            const preview = args.preview ? "_preview" : "";
+            const title = `${name}${environment}-${args.namespace}${preview}`;
 
             if (args.local) {
               const { Miniflare } = await import("miniflare");
@@ -1044,59 +1392,45 @@ export async function main(argv: string[]): Promise<void> {
                 // TODO: these options shouldn't be required
                 script: ` `, // has to be a string with at least one char
               });
-              mf.getKVNamespace(title); // this should "create" the namespace
+              await mf.getKVNamespace(title); // this should "create" the namespace
               console.log(`✨ Success! Created KV namespace ${title}`);
-              return;
-            }
-
-            // -- snip, extract --
-
-            if (!args.local) {
+            } else {
+              // -- 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) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
-            }
-
-            // -- snip, end --
+              // -- snip, end --
 
-            // TODO: generate a binding name stripping non alphanumeric chars
+              // TODO: generate a binding name stripping non alphanumeric chars
 
-            console.log(`🌀 Creating namespace with title "${title}"`);
+              console.log(`🌀 Creating namespace with title "${title}"`);
+              const namespaceId = await createNamespace(
+                config.account_id,
+                title
+              );
 
-            const response = await cfetch<{ id: string }>(
-              `/accounts/${config.account_id}/storage/kv/namespaces`,
-              {
-                method: "POST",
-                headers: {
-                  "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                  title,
-                }),
-              }
-            );
+              console.log("✨ Success!");
+              const envString = args.env ? ` under [env.${args.env}]` : "";
+              const previewString = args.preview ? "preview_" : "";
+              console.log(
+                `Add the following to your configuration file in your kv_namespaces array${envString}:`
+              );
+              console.log(
+                `{ binding = "${args.namespace}", ${previewString}id = "${namespaceId}" }`
+              );
 
-            console.log("✨ Success!");
-            console.log(
-              `Add the following to your configuration file in your kv_namespaces array${
-                args.env ? ` under [env.${args.env}]` : ""
-              }:`
-            );
-            console.log(
-              `{ binding = "${args.namespace}", ${
-                args.preview ? "preview_" : ""
-              }id = ${response.id} }`
-            );
+              // TODO: automatically write this block to the wrangler.toml config file??
+            }
           }
         )
         .command(
@@ -1104,42 +1438,39 @@ 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) {
-              console.error(`local mode is not yet supported for this command`);
-              return;
-            }
-
             const config = args.config as Config;
 
-            // -- snip, extract --
-
-            if (!args.local) {
+            if (args.local) {
+              throw new NotImplementedError(
+                `local mode is not yet supported for this command`
+              );
+            } else {
+              // -- 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) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
-            }
+              // -- snip, end --
 
-            // -- snip, end --
+              // TODO: we should show bindings if they exist for given ids
 
-            // TODO: we should show bindings if they exist for given ids
-
-            console.log(
-              JSON.stringify(
-                await listNamespaces(config.account_id),
-                null,
-                "  "
-              )
-            );
+              console.log(
+                JSON.stringify(
+                  await listNamespaces(config.account_id),
+                  null,
+                  "  "
+                )
+              );
+            }
           }
         )
         .command(
@@ -1166,27 +1497,23 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              console.error(`local mode is not yet supported for this command`);
-              return;
-            }
             const config = args.config as Config;
 
-            const id =
-              args["namespace-id"] ||
-              (args.env
-                ? config[`env.${args.env}`]
-                : config
-              ).kv_namespaces.find(
-                (namespace) => namespace.binding === args.binding
-              )[args.preview ? "preview_id" : "id"];
-            if (!id) {
-              throw new Error("Are you sure? id not found");
-            }
-
-            // -- snip, extract --
+            if (args.local) {
+              throw new NotImplementedError(
+                `local mode is not yet supported for this command`
+              );
+            } else {
+              let id;
+              try {
+                id = getNamespaceId(args);
+              } catch (e) {
+                throw new CommandLineArgsError(
+                  "Not able to delete namespace.\n" + e.message
+                );
+              }
 
-            if (!args.local) {
+              // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
               if (!loggedIn) {
                 // didn't login, let's just quit
@@ -1197,55 +1524,54 @@ export async function main(argv: string[]): Promise<void> {
               if (!config.account_id) {
                 config.account_id = await getAccountId();
                 if (!config.account_id) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
-            }
+              // -- snip, end --
 
-            // -- snip, end --
-
-            await cfetch<{ id: string }>(
-              `/accounts/${config.account_id}/storage/kv/namespaces/${id}`,
-              { method: "DELETE" }
-            );
+              await fetchResult<{ id: string }>(
+                `/accounts/${config.account_id}/storage/kv/namespaces/${id}`,
+                { method: "DELETE" }
+              );
 
-            // TODO: recommend they remove it from wrangler.toml
+              // TODO: recommend they remove it from wrangler.toml
 
-            // test-mf wrangler kv:namespace delete --namespace-id 2a7d3d8b23fc4159b5afa489d6cfd388
-            // Are you sure you want to delete namespace 2a7d3d8b23fc4159b5afa489d6cfd388? [y/n]
-            // n
-            // 💁  Not deleting namespace 2a7d3d8b23fc4159b5afa489d6cfd388
-            // ➜  test-mf wrangler kv:namespace delete --namespace-id 2a7d3d8b23fc4159b5afa489d6cfd388
-            // Are you sure you want to delete namespace 2a7d3d8b23fc4159b5afa489d6cfd388? [y/n]
-            // y
-            // 🌀  Deleting namespace 2a7d3d8b23fc4159b5afa489d6cfd388
-            // ✨  Success
-            // ⚠️  Make sure to remove this "kv-namespace" entry from your configuration file!
-            // ➜  test-mf
+              // test-mf wrangler kv:namespace delete --namespace-id 2a7d3d8b23fc4159b5afa489d6cfd388
+              // Are you sure you want to delete namespace 2a7d3d8b23fc4159b5afa489d6cfd388? [y/n]
+              // n
+              // 💁  Not deleting namespace 2a7d3d8b23fc4159b5afa489d6cfd388
+              // ➜  test-mf wrangler kv:namespace delete --namespace-id 2a7d3d8b23fc4159b5afa489d6cfd388
+              // Are you sure you want to delete namespace 2a7d3d8b23fc4159b5afa489d6cfd388? [y/n]
+              // y
+              // 🌀  Deleting namespace 2a7d3d8b23fc4159b5afa489d6cfd388
+              // ✨  Success
+              // ⚠️  Make sure to remove this "kv-namespace" entry from your configuration file!
+              // ➜  test-mf
 
-            // TODO: do it automatically
+              // TODO: do it automatically
 
-            // TODO: delete the preview namespace as well?
+              // TODO: delete the preview namespace as well?
+            }
           }
         );
     }
   );
 
   // :key
-  yargs.command(
+  wrangler.command(
     "kv:key",
     "🔑 Individually manage Workers KV key-value pairs",
-    (yargs) => {
-      return yargs
+    (kvKeyYargs) => {
+      return kvKeyYargs
         .command(
-          "put <key> <value>",
+          "put <key> [value]",
           "Writes a single key/value pair to the given namespace.",
           (yargs) => {
             return yargs
               .positional("key", {
                 type: "string",
                 describe: "The key to write to.",
+                demandOption: true,
               })
               .positional("value", {
                 type: "string",
@@ -1280,16 +1606,28 @@ export async function main(argv: string[]): Promise<void> {
               .option("path", {
                 type: "string",
                 describe: "Read value from the file at a given path.",
-              });
+              })
+              .check(demandOneOfOption("value", "path"));
           },
           async ({ key, ttl, expiration, ...args }) => {
             const namespaceId = getNamespaceId(args);
+            // One of `args.path` and `args.value` must be defined
             const value = args.path
               ? await readFile(args.path, "utf-8")
-              : args.value;
+              : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                args.value!;
             const config = args.config as Config;
 
-            console.log(`writing ${key}=${value} to namespace ${namespaceId}`);
+            if (args.path) {
+              console.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}`
+              );
+            }
+
             if (args.local) {
               const { Miniflare } = await import("miniflare");
               const mf = new Miniflare({
@@ -1299,11 +1637,8 @@ export async function main(argv: string[]): Promise<void> {
               });
               const ns = await mf.getKVNamespace(namespaceId);
               await ns.put(key, value, { expiration, expirationTtl: ttl });
-              return;
-            }
-            // -- snip, extract --
-
-            if (!args.local) {
+            } else {
+              // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
               if (!loggedIn) {
                 // didn't login, let's just quit
@@ -1314,18 +1649,16 @@ export async function main(argv: string[]): Promise<void> {
               if (!config.account_id) {
                 config.account_id = await getAccountId();
                 if (!config.account_id) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
-            }
-
-            // -- snip, end --
+              // -- snip, end --
 
-            await putKeyValue(config.account_id, namespaceId, key, value, {
-              expiration,
-              expiration_ttl: ttl,
-            });
+              await putKeyValue(config.account_id, namespaceId, key, value, {
+                expiration,
+                expiration_ttl: ttl,
+              });
+            }
           }
         )
         .command(
@@ -1346,6 +1679,12 @@ export async function main(argv: string[]): Promise<void> {
                 type: "string",
                 describe: "Perform on a specific environment",
               })
+              .option("preview", {
+                type: "boolean",
+                // In the case of listing keys we will default to non-preview mode
+                default: false,
+                describe: "Interact with a preview namespace",
+              })
               .option("prefix", {
                 type: "string",
                 describe: "A prefix to filter listed keys",
@@ -1367,12 +1706,8 @@ export async function main(argv: string[]): Promise<void> {
               const ns = await mf.getKVNamespace(namespaceId);
               const listResponse = await ns.list({ prefix });
               console.log(JSON.stringify(listResponse.keys, null, "  ")); // TODO: paginate, collate
-              return;
-            }
-
-            // -- snip, extract --
-
-            if (!args.local) {
+            } else {
+              // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
               if (!loggedIn) {
                 // didn't login, let's just quit
@@ -1383,17 +1718,18 @@ export async function main(argv: string[]): Promise<void> {
               if (!config.account_id) {
                 config.account_id = await getAccountId();
                 if (!config.account_id) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
-            }
-
-            // -- snip, end --
+              // -- 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(
@@ -1404,6 +1740,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",
@@ -1421,6 +1758,12 @@ export async function main(argv: string[]): Promise<void> {
               .option("preview", {
                 type: "boolean",
                 describe: "Interact with a preview namespace",
+              })
+              .option("preview", {
+                type: "boolean",
+                // In the case of getting key values we will default to non-preview mode
+                default: false,
+                describe: "Interact with a preview namespace",
               });
           },
           async ({ key, ...args }) => {
@@ -1439,9 +1782,8 @@ export async function main(argv: string[]): Promise<void> {
               return;
             }
 
-            // -- snip, extract --
-
             if (!args.local) {
+              // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
               if (!loggedIn) {
                 // didn't login, let's just quit
@@ -1452,23 +1794,15 @@ export async function main(argv: string[]): Promise<void> {
               if (!config.account_id) {
                 config.account_id = await getAccountId();
                 if (!config.account_id) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
-            }
-
-            // -- snip, end --
+              // -- snip, end --
 
-            // annoyingly, the API for this one doesn't return the
-            // data in the 'standard' format. goddamit.
-            // That's why we have the fallthrough response in cfetch.
-            // Oh well.
-            console.log(
-              await cfetch(
-                `/accounts/${config.account_id}/storage/kv/namespaces/${namespaceId}/values/${key}`
-              )
-            );
+              console.log(
+                await getKeyValue(config.account_id, namespaceId, key)
+              );
+            }
           }
         )
         .command(
@@ -1479,6 +1813,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",
@@ -1501,6 +1836,10 @@ export async function main(argv: string[]): Promise<void> {
           async ({ key, ...args }) => {
             const namespaceId = getNamespaceId(args);
 
+            console.log(
+              `deleting the key "${key}" on namespace ${namespaceId}`
+            );
+
             if (args.local) {
               const { Miniflare } = await import("miniflare");
               const mf = new Miniflare({
@@ -1515,9 +1854,8 @@ export async function main(argv: string[]): Promise<void> {
 
             const config = args.config as Config;
 
-            // -- snip, extract --
-
             if (!args.local) {
+              // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
               if (!loggedIn) {
                 // didn't login, let's just quit
@@ -1528,15 +1866,13 @@ export async function main(argv: string[]): Promise<void> {
               if (!config.account_id) {
                 config.account_id = await getAccountId();
                 if (!config.account_id) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
+              // -- snip, end --
             }
 
-            // -- snip, end --
-
-            await cfetch(
+            await fetchResult(
               `/accounts/${config.account_id}/storage/kv/namespaces/${namespaceId}/values/${key}`,
               { method: "DELETE" }
             );
@@ -1546,11 +1882,11 @@ export async function main(argv: string[]): Promise<void> {
   );
 
   // :bulk
-  yargs.command(
+  wrangler.command(
     "kv:bulk",
     "💪 Interact with multiple Workers KV key-value pairs at once",
-    (yargs) => {
-      return yargs
+    (kvBulkYargs) => {
+      return kvBulkYargs
         .command(
           "put <filename>",
           "Upload multiple key-value pairs to a namespace",
@@ -1559,6 +1895,7 @@ 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",
@@ -1590,8 +1927,9 @@ export async function main(argv: string[]): Promise<void> {
             try {
               parsedContent = JSON.parse(content);
             } catch (err) {
-              console.error(`could not parse json from ${filename}`);
-              throw err;
+              throw new Error(
+                `Could not parse json from ${filename}.\n${err.message ?? err}`
+              );
             }
 
             if (args.local) {
@@ -1613,13 +1951,8 @@ export async function main(argv: string[]): Promise<void> {
                   expirationTtl: expiration_ttl,
                 });
               }
-
-              return;
-            }
-
-            // -- snip, extract --
-
-            if (!args.local) {
+            } else {
+              // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
               if (!loggedIn) {
                 // didn't login, let's just quit
@@ -1630,27 +1963,26 @@ export async function main(argv: string[]): Promise<void> {
               if (!config.account_id) {
                 config.account_id = await getAccountId();
                 if (!config.account_id) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
-            }
-
-            // -- snip, end --
+              // -- snip, end --
 
-            console.log(
-              await putBulkKeyValue(config.account_id, namespaceId, content)
-            );
+              console.log(
+                await putBulkKeyValue(config.account_id, namespaceId, content)
+              );
+            }
           }
         )
         .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",
@@ -1678,8 +2010,9 @@ export async function main(argv: string[]): Promise<void> {
             try {
               parsedContent = JSON.parse(content);
             } catch (err) {
-              console.error(`could not parse json from ${filename}`);
-              throw err;
+              throw new Error(
+                `Could not parse json from ${filename}.\n${err.message ?? err}`
+              );
             }
 
             if (args.local) {
@@ -1693,13 +2026,8 @@ export async function main(argv: string[]): Promise<void> {
               for (const key of parsedContent) {
                 await ns.delete(key);
               }
-
-              return;
-            }
-
-            // -- snip, extract --
-
-            if (!args.local) {
+            } else {
+              // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
               if (!loggedIn) {
                 // didn't login, let's just quit
@@ -1710,26 +2038,29 @@ export async function main(argv: string[]): Promise<void> {
               if (!config.account_id) {
                 config.account_id = await getAccountId();
                 if (!config.account_id) {
-                  console.error("No account id found, quitting...");
-                  return;
+                  throw new Error("No account id found, quitting...");
                 }
               }
-            }
-
-            // -- snip, end --
+              // -- snip, end --
 
-            console.log(
-              await deleteBulkKeyValue(config.account_id, namespaceId, content)
-            );
+              console.log(
+                await deleteBulkKeyValue(
+                  config.account_id,
+                  namespaceId,
+                  content
+                )
+              );
+            }
           }
         );
     }
   );
 
-  yargs.command("pages", "⚡️ Configure Cloudflare Pages", pages);
+  wrangler.command("pages", "⚡️ Configure Cloudflare Pages", pages);
 
-  yargs
+  wrangler
     .option("config", {
+      alias: "c",
       describe: "Path to .toml configuration file",
       type: "string",
       async coerce(arg) {
@@ -1737,18 +2068,34 @@ export async function main(argv: string[]): Promise<void> {
       },
     })
     .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.
     });
 
-  yargs.group(["config", "help", "version"], "Flags:");
+  wrangler.group(["config", "help", "version"], "Flags:");
+  wrangler.help().alias("h", "help");
+  wrangler.version(wranglerVersion).alias("v", "version");
+  wrangler.exitProcess(false);
 
   await initialiseUserConfig();
-  await yargs.parse(argv, (err, argv, output) => {
-    if (output) {
-      console.log(output);
+
+  try {
+    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 {
+      console.error(e.message);
+      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."
+      );
     }
-  });
-  yargs.version(wranglerVersion);
+    throw e;
+  }
 }