wrangler 0.0.13 → 0.0.17

package/src/index.tsx

@@ -1,25 +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 type Yargs from "yargs";
-import { findUp } from "find-up";
-import TOML from "@iarna/toml";
+import { version as wranglerVersion } from "../package.json";
+import { toFormData } from "./api/form_data";
+import { fetchResult } from "./cfetch";
 import { normaliseAndValidateEnvironmentsConfig } from "./config";
-import type { Config } from "./config";
-import { getAssetPaths } from "./sites";
+import Dev from "./dev";
 import { confirm, prompt } from "./dialogs";
-import { version as wranglerVersion } from "../package.json";
-import {
-  login,
-  logout,
-  listScopes,
-  initialise as initialiseUserConfig,
-  loginOrRefreshIfRequired,
-  getAccountId,
-  validateScopeKeys,
-} from "./user";
 import {
   getNamespaceId,
   listNamespaces,
@@ -29,32 +23,60 @@ import {
   deleteBulkKeyValue,
   createNamespace,
   isValidNamespaceBinding,
+  getKeyValue,
 } from "./kv";
-
+import { getPackageManager } from "./package-manager";
 import { pages } from "./pages";
-
-import { fetchResult, fetchRaw } from "./cfetch";
-
 import publish from "./publish";
-import path from "path/posix";
-import { writeFile } from "node:fs/promises";
-import { toFormData } from "./api/form_data";
-
-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 { createR2Bucket, deleteR2Bucket, listR2Buckets } from "./r2";
+import { getAssetPaths } from "./sites";
+import {
+  createTail,
+  jsonPrintLogs,
+  prettyPrintLogs,
+  translateCliFiltersToApiFilters,
+} from "./tail";
+import {
+  login,
+  logout,
+  listScopes,
+  initialise as initialiseUserConfig,
+  loginOrRefreshIfRequired,
+  getAccountId,
+  validateScopeKeys,
+} from "./user";
 import { whoami } from "./whoami";
 
+import type { Entry } from "./bundle";
+import type { Config } from "./config";
+import type { TailCLIFilters } from "./tail";
+import type { RawData } from "ws";
+import type Yargs from "yargs";
+
 const resetColor = "\x1b[0m";
 const fgGreenColor = "\x1b[32m";
 
+// a set of binding types that are known to be supported by wrangler
+const knownBindings = [
+  "plain_text",
+  "json",
+  "kv_namespace",
+  "durable_object_namespace",
+];
+
+type ConfigPath = string | undefined;
+
+async function findWranglerToml(
+  referencePath: string = process.cwd()
+): Promise<ConfigPath> {
+  const configPath = await findUp("wrangler.toml", { cwd: referencePath });
+  return configPath;
+}
+
 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
+    configPath = await findWranglerToml();
   }
 
   if (configPath) {
@@ -65,21 +87,108 @@ async function readConfig(configPath?: string): Promise<Config> {
 
   normaliseAndValidateEnvironmentsConfig(config);
 
+  // The field "experimental_services" doesn't exist anymore
+  // in the config, but we still want to error about any older usage.
+  // TODO: remove this error before GA.
   if ("experimental_services" in config) {
+    throw new Error(
+      `The "experimental_services" field is no longer supported. Instead, use [[unsafe.bindings]] to enable experimental features. Add this to your wrangler.toml:
+
+${TOML.stringify({
+  unsafe: {
+    bindings: (config.experimental_services || []).map((serviceDefinition) => {
+      return {
+        name: serviceDefinition.name,
+        type: "service",
+        service: serviceDefinition.service,
+        environment: serviceDefinition.environment,
+      };
+    }),
+  },
+})}`
+    );
+  }
+
+  if (configPath && "wasm_modules" in config) {
+    // rewrite wasm_module paths to be absolute
+    const modules: Record<string, string> = {};
+    for (const [name, filePath] of Object.entries(config.wasm_modules || {})) {
+      modules[name] = path.relative(
+        process.cwd(),
+        path.join(path.dirname(configPath), filePath)
+      );
+    }
+    config.wasm_modules = modules;
+  }
+
+  if ("unsafe" 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"
+      "'unsafe' fields are experimental and may change or break at any time."
     );
   }
 
   // todo: validate, add defaults
   // let's just do some basics for now
 
-  // @ts-expect-error we're being sneaky here for now
+  for (const binding of config.unsafe?.bindings ?? []) {
+    if (knownBindings.includes(binding.type)) {
+      console.warn(
+        `Raw '${binding.type}' bindings are not directly supported by wrangler. Consider migrating to a ` +
+          `format for '${binding.type}' bindings that is supported by wrangler for optimal support: ` +
+          "https://developers.cloudflare.com/workers/cli-wrangler/configuration"
+      );
+    }
+  }
+
+  // @ts-expect-error we're being sneaky here
   config.__path__ = configPath;
 
   return config;
 }
 
+function getEntry(
+  args: { _: (string | number)[]; script: string | undefined },
+  config: Config
+): Entry {
+  // @ts-expect-error a hidden field
+  const wranglerTomlPath = config.__path__;
+  let file: string;
+  let directory = process.cwd();
+  if (args.script) {
+    // If the script name comes from the command line it is relative to the current working directory.
+    file = path.resolve(args.script);
+  } else {
+    // If the script name comes from the config, then it is relative to the wrangler.toml file.
+    if (config.build?.upload?.main === undefined) {
+      throw new Error(
+        `Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler ${args._[0]} path/to/script\`) or the \`build.upload.main\` config field.`
+      );
+    }
+    directory = path.resolve(
+      path.dirname(wranglerTomlPath),
+      config.build.upload.dir || ""
+    );
+    file = path.resolve(directory, config.build.upload.main);
+  }
+
+  if (!config.build?.command) {
+    let fileExists = false;
+    try {
+      // Use require.resolve to use node's resolution algorithm,
+      // this lets us use paths without explicit .js extension
+      // TODO: we should probably remove this, because it doesn't
+      // take into consideration other extensions like .tsx, .ts, .jsx, etc
+      fileExists = fs.existsSync(require.resolve(file));
+    } catch (e) {
+      // fail silently, usually means require.resolve threw MODULE_NOT_FOUND
+    }
+    if (fileExists === false) {
+      throw new Error(`Could not resolve "${file}".`);
+    }
+  }
+  return { file, directory };
+}
+
 // a helper to demand one of a set of options
 // via https://github.com/yargs/yargs/issues/1093#issuecomment-491299261
 function demandOneOfOption(...options: string[]) {
@@ -176,10 +285,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) {
@@ -192,7 +307,9 @@ export async function main(argv: string[]): Promise<void> {
         throw new CommandLineArgsError(message);
       }
 
-      const destination = path.join(process.cwd(), "wrangler.toml");
+      const packageManager = await getPackageManager(process.cwd());
+
+      const destination = "./wrangler.toml";
       if (fs.existsSync(destination)) {
         console.warn(`${destination} file already exists!`);
         const shouldContinue = await confirm(
@@ -206,41 +323,48 @@ export async function main(argv: string[]): Promise<void> {
         try {
           await writeFile(
             destination,
-            `compatibility_date = "${compatibilityDate}"` + "\n"
+            TOML.stringify({
+              name: args.name || path.basename(path.resolve(process.cwd())),
+              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}`
+            `Failed to create wrangler.toml.\n${(err as Error).message ?? err}`
           );
         }
       }
 
       let pathToPackageJson = await findUp("package.json");
+      let shouldCreatePackageJson = false;
+      const yesFlag = args.yes ?? false;
       if (!pathToPackageJson) {
         // If no package.json exists, ask to create one
-        const shouldCreatePackageJson = await confirm(
-          "No package.json found. Would you like 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"),
+            "./package.json",
             JSON.stringify(
               {
-                name: "worker",
-                version: "0.0.1",
+                name: args.name || path.basename(path.resolve(process.cwd())),
+                version: "0.0.0",
                 devDependencies: {
                   wrangler: wranglerVersion,
                 },
+                private: true,
               },
               null,
               "  "
             ) + "\n"
           );
-          await execa("npm", ["install", "--prefer-offline"], {
-            stdio: "inherit",
-          });
+          await packageManager.install();
           console.log(`✨ Created package.json`);
           pathToPackageJson = path.join(process.cwd(), "package.json");
         } else {
@@ -258,47 +382,38 @@ export async function main(argv: string[]): Promise<void> {
             packageJson.dependencies?.wrangler
           )
         ) {
-          const shouldInstall = await confirm(
-            "Would you like to install wrangler into your package.json?"
-          );
+          const shouldInstall =
+            yesFlag ||
+            (await confirm(
+              "Would you like to install wrangler into your package.json?"
+            ));
           if (shouldInstall) {
-            await execa(
-              "npm",
-              [
-                "install",
-                `wrangler@${wranglerVersion}`,
-                "--save-dev",
-                "--prefer-offline",
-              ],
-              {
-                stdio: "inherit",
-              }
-            );
+            await packageManager.addDevDeps(`wrangler@${wranglerVersion}`);
             console.log(`✨ Installed wrangler`);
           }
         }
       }
 
+      let isTypescriptProject = false;
       let pathToTSConfig = await findUp("tsconfig.json");
       if (!pathToTSConfig) {
         // If there's no tsconfig, offer to create one
         // and install @cloudflare/workers-types
-        if (await confirm("Would you like to use typescript?")) {
+        if (yesFlag || (await confirm("Would you like to use TypeScript?"))) {
+          isTypescriptProject = true;
           await writeFile(
-            path.join(process.cwd(), "tsconfig.json"),
+            "./tsconfig.json",
             JSON.stringify(
               {
                 compilerOptions: {
-                  target: "esnext",
-                  module: "esnext",
+                  target: "es2021",
+                  module: "es2022",
                   moduleResolution: "node",
-                  esModuleInterop: true,
                   allowJs: true,
                   allowSyntheticDefaultImports: true,
                   isolatedModules: true,
                   noEmit: true,
-                  lib: ["esnext"],
-                  jsx: "react",
+                  lib: ["es2021"],
                   resolveJsonModule: true,
                   types: ["@cloudflare/workers-types"],
                 },
@@ -307,22 +422,18 @@ export async function main(argv: string[]): Promise<void> {
               "  "
             ) + "\n"
           );
-          await execa(
-            "npm",
-            [
-              "install",
-              "@cloudflare/workers-types",
-              "--save-dev",
-              "--prefer-offline",
-            ],
-            { stdio: "inherit" }
+          await packageManager.addDevDeps(
+            "@cloudflare/workers-types",
+            "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(
@@ -338,18 +449,7 @@ export async function main(argv: string[]): Promise<void> {
             "Would you like to install the type definitions for Workers into your package.json?"
           );
           if (shouldInstall) {
-            await execa(
-              "npm",
-              [
-                "install",
-                "@cloudflare/workers-types",
-                "--save-dev",
-                "--prefer-offline",
-              ],
-              {
-                stdio: "inherit",
-              }
-            );
+            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
@@ -357,8 +457,102 @@ export async function main(argv: string[]): Promise<void> {
             console.log(
               `✨ Installed @cloudflare/workers-types.\nPlease add "@cloudflare/workers-types" to compilerOptions.types in your tsconfig.json`
             );
-          } else {
-            return;
+          }
+        }
+      }
+
+      const packageJsonContent = JSON.parse(
+        await readFile(pathToPackageJson, "utf-8")
+      );
+      const shouldWritePackageJsonScripts =
+        !packageJsonContent.scripts?.start &&
+        !packageJsonContent.scripts?.deploy &&
+        shouldCreatePackageJson;
+      async function writePackageJsonScripts(
+        isWritingScripts: boolean,
+        packagePath: string,
+        scriptPath: string
+      ) {
+        if (isWritingScripts) {
+          await writeFile(
+            packagePath,
+            JSON.stringify(
+              {
+                ...packageJsonContent,
+                scripts: {
+                  ...packageJsonContent.scripts,
+                  start: `wrangler dev ${scriptPath}`,
+                  deploy: `wrangler publish ${scriptPath}`,
+                },
+              },
+              null,
+              "  "
+            ) + "\n"
+          );
+          console.log(`To start developing on your worker, run npm start.`);
+          console.log(
+            `To publish your worker on to the internet, run npm run deploy.`
+          );
+        } else {
+          console.log(
+            `To start developing on your worker, npx wrangler dev ${scriptPath}`
+          );
+          console.log(
+            `To publish your worker on to the internet, npx wrangler publish ${scriptPath}`
+          );
+        }
+      }
+      if (isTypescriptProject) {
+        if (!fs.existsSync("./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("./src", { recursive: true });
+            await writeFile(
+              "./src/index.ts",
+              await readFile(
+                path.join(__dirname, "../templates/new-worker.ts"),
+                "utf-8"
+              )
+            );
+
+            await writePackageJsonScripts(
+              shouldWritePackageJsonScripts,
+              pathToPackageJson,
+              "src/index.ts"
+            );
+
+            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"
+              )
+            );
+
+            await writePackageJsonScripts(
+              shouldWritePackageJsonScripts,
+              pathToPackageJson,
+              "src/index.js"
+            );
+
+            console.log(`✨ Created src/index.js`);
           }
         }
       }
@@ -467,14 +661,13 @@ 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", {
+        .positional("script", {
           describe: "entry point",
           type: "string",
-          demandOption: true,
         })
         .option("name", {
           describe: "name of the script",
@@ -556,11 +749,18 @@ export async function main(argv: string[]): Promise<void> {
         .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;
+      const config = await readConfig(
+        (args.config as ConfigPath) ||
+          (args.script && (await findWranglerToml(path.dirname(args.script))))
+      );
+      const entry = getEntry(args, config);
 
       if (args["experimental-public"]) {
         console.warn(
@@ -617,12 +817,16 @@ export async function main(argv: string[]): Promise<void> {
       const { waitUntilExit } = render(
         <Dev
           name={args.name || config.name}
-          entry={path.relative(process.cwd(), filename)}
+          entry={entry}
+          env={args.env}
           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}
           assetPaths={getAssetPaths(
             config,
@@ -665,8 +869,10 @@ export async function main(argv: string[]): Promise<void> {
               }
             ),
             vars: envRootObj.vars,
+            wasm_modules: config.wasm_modules,
             durable_objects: envRootObj.durable_objects,
-            services: envRootObj.experimental_services,
+            r2_buckets: envRootObj.r2_buckets,
+            unsafe: envRootObj.unsafe?.bindings,
           }}
         />
       );
@@ -692,6 +898,10 @@ export async function main(argv: string[]): Promise<void> {
           describe: "name to use when uploading",
           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",
@@ -736,12 +946,6 @@ export async function main(argv: string[]): Promise<void> {
           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",
@@ -769,7 +973,11 @@ export async function main(argv: string[]): Promise<void> {
         );
       }
 
-      const config = args.config as Config;
+      const config = await readConfig(
+        (args.config as ConfigPath) ||
+          (args.script && (await findWranglerToml(path.dirname(args.script))))
+      );
+      const entry = getEntry(args, config);
 
       if (args.latest) {
         console.warn(
@@ -802,9 +1010,10 @@ export async function main(argv: string[]): Promise<void> {
         args.siteExclude
       );
       await publish({
-        config: args.config as Config,
+        config,
         name: args.name,
-        script: args.script,
+        format: args.format || config.build?.upload?.format,
+        entry,
         env: args.env,
         compatibilityDate: args.latest
           ? new Date().toISOString().substring(0, 10)
@@ -815,7 +1024,6 @@ export async function main(argv: string[]): Promise<void> {
         jsxFragment: args["jsx-fragment"],
         routes: args.routes,
         assetPaths,
-        format: undefined, // TODO: add args for this
         legacyEnv: undefined, // TODO: get this from somewhere... config?
         experimentalPublic: args["experimental-public"] !== undefined,
       });
@@ -842,6 +1050,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",
@@ -850,6 +1059,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",
@@ -859,12 +1069,18 @@ 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,
+          })
+          // TODO: is this deprecated now with services / environments / etc?
           .option("env", {
             type: "string",
             describe: "Perform on a specific environment",
           })
       );
-      // TODO: filter by client ip, which can be 'self' or an ip address
     },
     async (args) => {
       if (args.local) {
@@ -873,14 +1089,13 @@ export async function main(argv: string[]): Promise<void> {
         );
       }
 
-      const config = args.config as Config;
+      const config = await readConfig(args.config as ConfigPath);
 
-      if (!(args.name || config.name)) {
+      const shortScriptName = args.name || config.name;
+      if (!shortScriptName) {
         throw new Error("Missing script name");
       }
-      const scriptName = `${args.name || config.name}${
-        args.env ? `-${args.env}` : ""
-      }`;
+      const scriptName = `${shortScriptName}${args.env ? `-${args.env}` : ""}`;
 
       // -- snip, extract --
       const loggedIn = await loginOrRefreshIfRequired();
@@ -900,14 +1115,17 @@ export async function main(argv: string[]): Promise<void> {
 
       const accountId = config.account_id;
 
-      const filters = {
-        status: args.status as "ok" | "error" | "canceled",
+      const cliFilters: TailCLIFilters = {
+        status: args.status as Array<"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 filters = translateCliFiltersToApiFilters(cliFilters);
+
       const { tail, expiration, /* sendHeartbeat, */ deleteTail } =
         await createTail(accountId, scriptName, filters);
 
@@ -920,9 +1138,10 @@ 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) {
@@ -938,6 +1157,11 @@ export async function main(argv: string[]): Promise<void> {
       }
 
       console.log(`Connected to ${scriptName}, waiting for logs...`);
+
+      tail.on("close", async () => {
+        tail.terminate();
+        await deleteTail();
+      });
     }
   );
 
@@ -1003,7 +1227,8 @@ export async function main(argv: string[]): Promise<void> {
           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;
+            const config = await readConfig(args.config as ConfigPath);
+            const zone = args.zone || config.zone_id;
             if (!zone) {
               throw new Error("missing zone id");
             }
@@ -1032,7 +1257,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 = await readConfig(args.config as ConfigPath);
+            const zone = args.zone || config.zone_id;
             if (!zone) {
               throw new Error("missing zone id");
             }
@@ -1088,12 +1314,7 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                "--local not implemented for this command yet"
-              );
-            }
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
 
             // TODO: use environment (how does current wrangler do it?)
             const scriptName = args.name || config.name;
@@ -1101,6 +1322,10 @@ export async function main(argv: string[]): Promise<void> {
               throw new Error("Missing script name");
             }
 
+            if (args.local) {
+              console.warn("`wrangler secret put` is a no-op in --local mode");
+            }
+
             if (!args.local) {
               // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
@@ -1123,6 +1348,13 @@ export async function main(argv: string[]): Promise<void> {
               "Enter a secret value:",
               "password"
             );
+
+            if (args.local) {
+              return;
+            }
+
+            console.log(`🌀 Creating the secret for script ${scriptName}`);
+
             async function submitSecret() {
               return await fetchResult(
                 `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets/`,
@@ -1139,16 +1371,17 @@ export async function main(argv: string[]): Promise<void> {
             }
 
             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
                 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() {} }`,
@@ -1158,17 +1391,25 @@ export async function main(argv: string[]): Promise<void> {
                         kv_namespaces: [],
                         vars: {},
                         durable_objects: { bindings: [] },
+                        r2_buckets: [],
+                        wasm_modules: {},
+                        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(
@@ -1191,12 +1432,7 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                "--local not implemented for this command yet"
-              );
-            }
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
 
             // TODO: use environment (how does current wrangler do it?)
             const scriptName = args.name || config.name;
@@ -1204,6 +1440,12 @@ export async function main(argv: string[]): Promise<void> {
               throw new Error("Missing script name");
             }
 
+            if (args.local) {
+              console.warn(
+                "`wrangler secret delete` is a no-op in --local mode"
+              );
+            }
+
             if (!args.local) {
               // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
@@ -1222,17 +1464,24 @@ export async function main(argv: string[]): Promise<void> {
               // -- 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 fetchResult(
-                  `/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}`);
             }
           }
         )
@@ -1252,12 +1501,7 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                "--local not implemented for this command yet"
-              );
-            }
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
 
             // TODO: use environment (how does current wrangler do it?)
             const scriptName = args.name || config.name;
@@ -1265,6 +1509,10 @@ export async function main(argv: string[]): Promise<void> {
               throw new Error("Missing script name");
             }
 
+            if (args.local) {
+              console.warn("`wrangler secret list` is a no-op in --local mode");
+            }
+
             if (!args.local) {
               // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
@@ -1283,9 +1531,17 @@ export async function main(argv: string[]): Promise<void> {
               // -- snip, end --
             }
 
+            if (args.local) {
+              return;
+            }
+
             console.log(
-              await fetchResult(
-                `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
+              JSON.stringify(
+                await fetchResult(
+                  `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
+                ),
+                null,
+                "  "
               )
             );
           }
@@ -1333,7 +1589,7 @@ export async function main(argv: string[]): Promise<void> {
               );
             }
 
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
             if (!config.name) {
               console.warn(
                 "No configured name present, using `worker` as a prefix for the title"
@@ -1398,7 +1654,7 @@ export async function main(argv: string[]): Promise<void> {
           "Outputs a list of all KV namespaces associated with your account id.",
           {},
           async (args) => {
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
 
             if (args.local) {
               throw new NotImplementedError(
@@ -1457,7 +1713,7 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
 
             if (args.local) {
               throw new NotImplementedError(
@@ -1466,10 +1722,11 @@ export async function main(argv: string[]): Promise<void> {
             } else {
               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)
                 );
               }
 
@@ -1570,13 +1827,13 @@ export async function main(argv: string[]): Promise<void> {
               .check(demandOneOfOption("value", "path"));
           },
           async ({ key, ttl, expiration, ...args }) => {
-            const namespaceId = getNamespaceId(args);
+            const config = await 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")
               : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 args.value!;
-            const config = args.config as Config;
 
             if (args.path) {
               console.log(
@@ -1652,9 +1909,8 @@ export async function main(argv: string[]): Promise<void> {
           },
           async ({ prefix, ...args }) => {
             // TODO: support for limit+cursor (pagination)
-
-            const namespaceId = getNamespaceId(args);
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, config);
 
             if (args.local) {
               const { Miniflare } = await import("miniflare");
@@ -1727,8 +1983,8 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ key, ...args }) => {
-            const namespaceId = getNamespaceId(args);
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, config);
 
             if (args.local) {
               const { Miniflare } = await import("miniflare");
@@ -1758,13 +2014,11 @@ export async function main(argv: string[]): Promise<void> {
                 }
               }
               // -- 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(
@@ -1796,7 +2050,8 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ key, ...args }) => {
-            const namespaceId = getNamespaceId(args);
+            const config = await readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, config);
 
             console.log(
               `deleting the key "${key}" on namespace ${namespaceId}`
@@ -1814,8 +2069,6 @@ export async function main(argv: string[]): Promise<void> {
               return;
             }
 
-            const config = args.config as Config;
-
             if (!args.local) {
               // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
@@ -1881,16 +2134,17 @@ export async function main(argv: string[]): Promise<void> {
             // The simplest implementation I could think of.
             // This could be made more efficient with a streaming parser/uploader
             // but we'll do that in the future if needed.
-
-            const namespaceId = getNamespaceId(args);
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, 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}`
+                `Could not parse json from ${filename}.\n${
+                  (err as Error).message ?? err
+                }`
               );
             }
 
@@ -1965,15 +2219,18 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async ({ filename, ...args }) => {
-            const namespaceId = getNamespaceId(args);
-            const config = args.config as Config;
+            const config = await readConfig(args.config as ConfigPath);
+            const namespaceId = getNamespaceId(args, 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}`
+                `Could not parse json from ${filename}.\n${
+                  (err as Error).message ?? err
+                }`
               );
             }
 
@@ -2020,14 +2277,144 @@ 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 = await readConfig(args.config as ConfigPath);
+
+          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) {
+                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 = await readConfig(args.config as ConfigPath);
+
+        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) {
+              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 = await readConfig(args.config as ConfigPath);
+
+          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) {
+                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("config", {
       alias: "c",
       describe: "Path to .toml configuration file",
       type: "string",
-      async coerce(arg) {
-        return await readConfig(arg);
-      },
     })
     .option("local", {
       alias: "l",
@@ -2041,9 +2428,8 @@ export async function main(argv: string[]): Promise<void> {
   wrangler.version(wranglerVersion).alias("v", "version");
   wrangler.exitProcess(false);
 
-  await initialiseUserConfig();
-
   try {
+    await initialiseUserConfig();
     await wrangler.parse();
   } catch (e) {
     if (e instanceof CommandLineArgsError) {
@@ -2051,7 +2437,7 @@ export async function main(argv: string[]): Promise<void> {
       console.error(""); // Just adds a bit of space
       console.error(e.message);
     } else {
-      console.error(e.message);
+      console.error(e instanceof Error ? e.message : e);
       console.error(""); // Just adds a bit of space
       console.error(
         `${fgGreenColor}%s${resetColor}`,