wrangler 2.0.6 → 2.0.9

package/src/index.tsx

@@ -11,14 +11,15 @@ import { render } from "ink";
 import React from "react";
 import onExit from "signal-exit";
 import supportsColor from "supports-color";
+import { setGlobalDispatcher, ProxyAgent } from "undici";
 import makeCLI from "yargs";
 import { version as wranglerVersion } from "../package.json";
 import { fetchResult } from "./cfetch";
-import { findWranglerToml, readConfig } from "./config";
+import { findWranglerToml, printBindings, readConfig } from "./config";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
 import Dev from "./dev/dev";
 import { getVarsForDev } from "./dev/dev-vars";
-import { confirm, prompt } from "./dialogs";
+import { confirm, prompt, select } from "./dialogs";
 import { getEntry } from "./entry";
 import { DeprecationError } from "./errors";
 import {
@@ -43,6 +44,7 @@ import {
   formatMessage,
   ParseError,
   parseJSON,
+  parsePackageJSON,
   parseTOML,
   readFileSync,
 } from "./parse";
@@ -64,6 +66,7 @@ import {
   requireAuth,
 } from "./user";
 import { whoami } from "./whoami";
+import { getZoneIdFromHost, getZoneForRoute } from "./zones";
 
 import type { Config } from "./config";
 import type { TailCLIFilters } from "./tail";
@@ -77,6 +80,17 @@ const resetColor = "\x1b[0m";
 const fgGreenColor = "\x1b[32m";
 const DEFAULT_LOCAL_PORT = 8787;
 
+const proxy =
+  process.env.https_proxy ||
+  process.env.HTTPS_PROXY ||
+  process.env.http_proxy ||
+  process.env.HTTP_PROXY ||
+  undefined;
+
+if (proxy) {
+  setGlobalDispatcher(new ProxyAgent(proxy));
+}
+
 function getRules(config: Config): Config["rules"] {
   const rules = config.rules ?? config.build?.upload?.rules ?? [];
 
@@ -333,6 +347,9 @@ function createCLIParser(argv: string[]) {
         throw new CommandLineArgsError(message);
       }
 
+      const devDepsToInstall: string[] = [];
+      const instructions: string[] = [];
+      let shouldRunPackageManagerInstall = false;
       const creationDirectory = path.resolve(process.cwd(), args.name ?? "");
 
       if (args.site) {
@@ -428,7 +445,12 @@ function createCLIParser(argv: string[]) {
           yesFlag ||
           (await confirm("Would you like to use git to manage this Worker?"));
         if (shouldInitGit) {
-          await execa("git", ["init"], { cwd: creationDirectory });
+          await execa("git", ["init"], {
+            cwd: creationDirectory,
+          });
+          await execa("git", ["branch", "-m", "main"], {
+            cwd: creationDirectory,
+          });
           await writeFile(
             path.join(creationDirectory, ".gitignore"),
             readFileSync(path.join(__dirname, "../templates/gitignore"))
@@ -474,7 +496,7 @@ function createCLIParser(argv: string[]) {
             ) + "\n"
           );
 
-          await packageManager.install();
+          shouldRunPackageManagerInstall = true;
           pathToPackageJson = path.join(creationDirectory, "package.json");
           logger.log(
             `✨ Created ${path.relative(process.cwd(), pathToPackageJson)}`
@@ -485,7 +507,7 @@ function createCLIParser(argv: string[]) {
       } else {
         // If package.json exists and wrangler isn't installed,
         // then ask to add wrangler to devDependencies
-        const packageJson = parseJSON(
+        const packageJson = parsePackageJSON(
           readFileSync(pathToPackageJson),
           pathToPackageJson
         );
@@ -504,8 +526,7 @@ function createCLIParser(argv: string[]) {
               )}?`
             ));
           if (shouldInstall) {
-            await packageManager.addDevDeps(`wrangler@${wranglerVersion}`);
-            logger.log(`✨ Installed wrangler`);
+            devDepsToInstall.push(`wrangler@${wranglerVersion}`);
           }
         }
       }
@@ -523,23 +544,18 @@ function createCLIParser(argv: string[]) {
             path.join(creationDirectory, "./tsconfig.json"),
             readFileSync(path.join(__dirname, "../templates/tsconfig.json"))
           );
-          await packageManager.addDevDeps(
-            "@cloudflare/workers-types",
-            "typescript"
-          );
+          devDepsToInstall.push("@cloudflare/workers-types");
+          devDepsToInstall.push("typescript");
           pathToTSConfig = path.join(creationDirectory, "tsconfig.json");
           logger.log(
-            `✨ Created ${path.relative(
-              process.cwd(),
-              pathToTSConfig
-            )}, installed @cloudflare/workers-types into devDependencies`
+            `✨ Created ${path.relative(process.cwd(), pathToTSConfig)}`
           );
         }
       } else {
         isTypescriptProject = true;
         // If there's a tsconfig, check if @cloudflare/workers-types
         // is already installed, and offer to install it if not
-        const packageJson = parseJSON(
+        const packageJson = parsePackageJSON(
           readFileSync(pathToPackageJson),
           pathToPackageJson
         );
@@ -553,13 +569,13 @@ function createCLIParser(argv: string[]) {
             "Would you like to install the type definitions for Workers into your package.json?"
           );
           if (shouldInstall) {
-            await packageManager.addDevDeps("@cloudflare/workers-types");
+            devDepsToInstall.push("@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
-            logger.log(
-              `✨ Installed @cloudflare/workers-types.\nPlease add "@cloudflare/workers-types" to compilerOptions.types in ${path.relative(
+            instructions.push(
+              `🚨 Please add "@cloudflare/workers-types" to compilerOptions.types in ${path.relative(
                 process.cwd(),
                 pathToTSConfig
               )}`
@@ -568,7 +584,7 @@ function createCLIParser(argv: string[]) {
         }
       }
 
-      const packageJsonContent = parseJSON(
+      const packageJsonContent = parsePackageJSON(
         readFileSync(pathToPackageJson),
         pathToPackageJson
       );
@@ -577,25 +593,60 @@ function createCLIParser(argv: string[]) {
         !packageJsonContent.scripts?.publish &&
         shouldCreatePackageJson;
 
+      /*
+       * Passes the array of accumulated devDeps to install through to
+       * the package manager. Also generates a human-readable list
+       * of packages it installed.
+       * If there are no devDeps to install, optionally runs
+       * the package manager's install command.
+       */
+      async function installPackages(
+        shouldRunInstall: boolean,
+        depsToInstall: string[]
+      ) {
+        //lets install the devDeps they asked for
+        //and run their package manager's install command if needed
+        if (depsToInstall.length > 0) {
+          const formatter = new Intl.ListFormat("en", {
+            style: "long",
+            type: "conjunction",
+          });
+          await packageManager.addDevDeps(...depsToInstall);
+          const versionlessPackages = depsToInstall.map((dep) =>
+            dep === `wrangler@${wranglerVersion}` ? "wrangler" : dep
+          );
+
+          logger.log(
+            `✨ Installed ${formatter.format(
+              versionlessPackages
+            )} into devDependencies`
+          );
+        } else {
+          if (shouldRunInstall) {
+            await packageManager.install();
+          }
+        }
+      }
+
       async function writePackageJsonScriptsAndUpdateWranglerToml(
         isWritingScripts: boolean,
         isCreatingWranglerToml: boolean,
         packagePath: string,
-        scriptPath: string
+        scriptPath: string,
+        extraToml: TOML.JsonMap
       ) {
         if (isCreatingWranglerToml) {
-          // rewrite wrangler.toml with main = "path/to/script"
+          // rewrite wrangler.toml with main = "path/to/script" and any additional config specified in `extraToml`
           const parsedWranglerToml = parseTOML(
             readFileSync(wranglerTomlDestination)
           );
-          fs.writeFileSync(
-            wranglerTomlDestination,
-            TOML.stringify({
-              name: parsedWranglerToml.name,
-              main: scriptPath,
-              compatibility_date: parsedWranglerToml.compatibility_date,
-            })
-          );
+          const newToml = {
+            name: parsedWranglerToml.name,
+            main: scriptPath,
+            compatibility_date: parsedWranglerToml.compatibility_date,
+            ...extraToml,
+          };
+          fs.writeFileSync(wranglerTomlDestination, TOML.stringify(newToml));
         }
         const isNamedWorker =
           isCreatingWranglerToml && path.dirname(packagePath) !== process.cwd();
@@ -611,7 +662,7 @@ function createCLIParser(argv: string[]) {
                   start: isCreatingWranglerToml
                     ? `wrangler dev`
                     : `wrangler dev ${scriptPath}`,
-                  publish: isCreatingWranglerToml
+                  deploy: isCreatingWranglerToml
                     ? `wrangler publish`
                     : `wrangler publish ${scriptPath}`,
                 },
@@ -620,21 +671,21 @@ function createCLIParser(argv: string[]) {
               2
             ) + "\n"
           );
-          logger.log(
+          instructions.push(
             `\nTo start developing your Worker, run \`${
               isNamedWorker ? `cd ${args.name} && ` : ""
             }npm start\``
           );
-          logger.log(
-            `To publish your Worker to the Internet, run \`npm run publish\``
+          instructions.push(
+            `To publish your Worker to the Internet, run \`npm run deploy\``
           );
         } else {
-          logger.log(
+          instructions.push(
             `\nTo start developing your Worker, run \`npx wrangler dev\`${
               isCreatingWranglerToml ? "" : ` ${scriptPath}`
             }`
           );
-          logger.log(
+          instructions.push(
             `To publish your Worker to the Internet, run \`npx wrangler publish\`${
               isCreatingWranglerToml ? "" : ` ${scriptPath}`
             }`
@@ -642,24 +693,75 @@ function createCLIParser(argv: string[]) {
         }
       }
 
+      async function getNewWorkerType(newWorkerFilename: string) {
+        return select(
+          `Would you like to create a Worker at ${newWorkerFilename}?`,
+          [
+            {
+              value: "none",
+              label: "None",
+            },
+            {
+              value: "fetch",
+              label: "Fetch handler",
+            },
+            {
+              value: "scheduled",
+              label: "Scheduled handler",
+            },
+          ],
+          1
+        ) as Promise<"none" | "fetch" | "scheduled">;
+      }
+
+      function getNewWorkerTemplate(
+        lang: "js" | "ts",
+        workerType: "fetch" | "scheduled"
+      ) {
+        const templates = {
+          "js-fetch": "new-worker.js",
+          "js-scheduled": "new-worker-scheduled.js",
+          "ts-fetch": "new-worker.ts",
+          "ts-scheduled": "new-worker-scheduled.ts",
+        };
+
+        return templates[`${lang}-${workerType}`];
+      }
+
+      function getNewWorkerToml(
+        workerType: "fetch" | "scheduled"
+      ): TOML.JsonMap {
+        if (workerType === "scheduled") {
+          return {
+            triggers: {
+              crons: ["1 * * * *"],
+            },
+          };
+        }
+
+        return {};
+      }
+
       if (isTypescriptProject) {
         if (!fs.existsSync(path.join(creationDirectory, "./src/index.ts"))) {
-          const shouldCreateSource =
-            yesFlag ||
-            (await confirm(
-              `Would you like to create a Worker at ${path.relative(
-                process.cwd(),
-                path.join(creationDirectory, "./src/index.ts")
-              )}?`
-            ));
+          const newWorkerFilename = path.relative(
+            process.cwd(),
+            path.join(creationDirectory, "./src/index.ts")
+          );
+
+          const newWorkerType = yesFlag
+            ? "fetch"
+            : await getNewWorkerType(newWorkerFilename);
+
+          if (newWorkerType !== "none") {
+            const template = getNewWorkerTemplate("ts", newWorkerType);
 
-          if (shouldCreateSource) {
             await mkdir(path.join(creationDirectory, "./src"), {
               recursive: true,
             });
             await writeFile(
               path.join(creationDirectory, "./src/index.ts"),
-              readFileSync(path.join(__dirname, "../templates/new-worker.ts"))
+              readFileSync(path.join(__dirname, `../templates/${template}`))
             );
 
             logger.log(
@@ -673,28 +775,31 @@ function createCLIParser(argv: string[]) {
               shouldWritePackageJsonScripts,
               justCreatedWranglerToml,
               pathToPackageJson,
-              "src/index.ts"
+              "src/index.ts",
+              getNewWorkerToml(newWorkerType)
             );
           }
         }
       } else {
         if (!fs.existsSync(path.join(creationDirectory, "./src/index.js"))) {
-          const shouldCreateSource =
-            yesFlag ||
-            (await confirm(
-              `Would you like to create a Worker at ${path.relative(
-                process.cwd(),
-                path.join(creationDirectory, "./src/index.js")
-              )}?`
-            ));
+          const newWorkerFilename = path.relative(
+            process.cwd(),
+            path.join(creationDirectory, "./src/index.js")
+          );
+
+          const newWorkerType = yesFlag
+            ? "fetch"
+            : await getNewWorkerType(newWorkerFilename);
+
+          if (newWorkerType !== "none") {
+            const template = getNewWorkerTemplate("js", newWorkerType);
 
-          if (shouldCreateSource) {
             await mkdir(path.join(creationDirectory, "./src"), {
               recursive: true,
             });
             await writeFile(
               path.join(creationDirectory, "./src/index.js"),
-              readFileSync(path.join(__dirname, "../templates/new-worker.js"))
+              readFileSync(path.join(__dirname, `../templates/${template}`))
             );
 
             logger.log(
@@ -708,11 +813,27 @@ function createCLIParser(argv: string[]) {
               shouldWritePackageJsonScripts,
               justCreatedWranglerToml,
               pathToPackageJson,
-              "src/index.js"
+              "src/index.js",
+              getNewWorkerToml(newWorkerType)
             );
           }
         }
       }
+      // install packages as the final step of init
+      try {
+        await installPackages(shouldRunPackageManagerInstall, devDepsToInstall);
+      } catch (e) {
+        // fetching packages could fail due to loss of internet, etc
+        // we should let folks know we failed to fetch, but their
+        // workers project is still ready to go
+        logger.error(e instanceof Error ? e.message : e);
+        instructions.push(
+          "\n🚨 wrangler was unable to fetch your npm packages, but your project is ready to go"
+        );
+      }
+
+      // let users know what to do now
+      instructions.forEach((instruction) => logger.log(instruction));
     }
   );
 
@@ -723,13 +844,34 @@ function createCLIParser(argv: string[]) {
     (yargs) => {
       return yargs.option("env", {
         describe: "Perform on a specific environment",
+        type: "string",
       });
     },
-    () => {
+    async (buildArgs) => {
       // "[DEPRECATED] 🦀 Build your project (if applicable)",
-      throw new DeprecationError(
-        "`wrangler build` has been deprecated, please refer to https://developers.cloudflare.com/workers/wrangler/migration/deprecations/#build for alternatives"
+
+      const envFlag = buildArgs.env ? ` --env=${buildArgs.env}` : "";
+      logger.log(
+        formatMessage({
+          kind: "warning",
+          text: "Deprecation: `wrangler build` has been deprecated.",
+          notes: [
+            {
+              text: "Please refer to https://developers.cloudflare.com/workers/wrangler/migration/deprecations/#build for more information.",
+            },
+            {
+              text: `Attempting to run \`wrangler publish --dry-run --outdir=dist${envFlag}\` for you instead:`,
+            },
+          ],
+        })
       );
+
+      await createCLIParser([
+        "publish",
+        "--dry-run",
+        "--outdir=dist",
+        ...(buildArgs.env ? ["--env", buildArgs.env] : []),
+      ]).parse();
     }
   );
 
@@ -941,92 +1083,25 @@ function createCLIParser(argv: string[]) {
         );
       }
 
-      const accountId = !args.local ? await requireAuth(config) : undefined;
-
       // TODO: if worker_dev = false and no routes, then error (only for dev)
 
-      /**
-       * Given something that resembles a URL,
-       * try to extract a host from it
-       */
-      function getHost(urlLike: string): string | undefined {
-        // strip leading * / *.
-        urlLike = urlLike.replace(/^\*(\.)?/g, "");
-
-        if (
-          !(urlLike.startsWith("http://") || urlLike.startsWith("https://"))
-        ) {
-          urlLike = "http://" + urlLike;
-        }
-        return new URL(urlLike).host;
-      }
-
-      /**
-       * Given something that resembles a host,
-       * try to infer a zone id from it
-       */
-      async function getZoneId(host: string): Promise<string | undefined> {
-        const zones = await fetchResult<{ id: string }[]>(
-          `/zones`,
-          {},
-          new URLSearchParams({ name: host })
-        );
-        return zones[0]?.id;
-      }
-
-      // When we're given a host (in one of the above ways), we do 2 things:
-      // - We try to extract a host from it
-      // - We try to get a zone id from the host
-      //
-      // So it turns out it's particularly hard to get a 'valid' domain
-      // from a string, so we don't even try to validate TLDs, etc.
-      // Once we get something that looks like w.x.y.z-ish, we then try to
-      // get a zone id for it, by lopping off subdomains until we get a hit
-      // from the API. That's it!
-
-      let zone: { host: string; id: string } | undefined;
+      // Compute zone info from the `host` and `route` args and config;
+      let host = args.host || config.dev.host;
+      let zoneId: string | undefined;
 
       if (!args.local) {
-        const hostLike =
-          args.host ||
-          config.dev.host ||
-          (args.routes && args.routes[0]) ||
-          config.route ||
-          (config.routes && config.routes[0]);
-
-        let zoneId: string | undefined =
-          typeof hostLike === "object" && "zone_id" in hostLike
-            ? hostLike.zone_id
-            : undefined;
-
-        const host =
-          typeof hostLike === "string"
-            ? getHost(hostLike)
-            : typeof hostLike === "object"
-            ? "zone_name" in hostLike
-              ? getHost(hostLike.zone_name)
-              : getHost(hostLike.pattern)
-            : undefined;
-
-        const hostPieces =
-          typeof host === "string" ? host.split(".") : undefined;
-
-        while (!zoneId && hostPieces && hostPieces.length > 1) {
-          zoneId = await getZoneId(hostPieces.join("."));
-          hostPieces.shift();
+        if (host) {
+          zoneId = await getZoneIdFromHost(host);
         }
-
-        if (host && !zoneId) {
-          throw new Error(`Could not find zone for ${hostLike}`);
+        const routes = args.routes || config.route || config.routes;
+        if (!zoneId && routes) {
+          const firstRoute = Array.isArray(routes) ? routes[0] : routes;
+          const zone = await getZoneForRoute(firstRoute);
+          if (zone) {
+            zoneId = zone.id;
+            host = zone.host;
+          }
         }
-
-        zone =
-          typeof zoneId === "string" && typeof host === "string"
-            ? {
-                host,
-                id: zoneId,
-              }
-            : undefined;
       }
 
       const nodeCompat = args.nodeCompat ?? config.node_compat;
@@ -1036,12 +1111,77 @@ function createCLIParser(argv: string[]) {
         );
       }
 
+      const bindings = {
+        kv_namespaces: config.kv_namespaces?.map(
+          ({ binding, preview_id, id: _id }) => {
+            // In `dev`, we make folks use a separate kv namespace called
+            // `preview_id` instead of `id` so that they don't
+            // break production data. So here we check that a `preview_id`
+            // has actually been configured.
+            // This whole block of code will be obsoleted in the future
+            // when we have copy-on-write for previews on edge workers.
+            if (!preview_id) {
+              // TODO: This error has to be a _lot_ better, ideally just asking
+              // to create a preview namespace for the user automatically
+              throw new Error(
+                `In development, you should use a separate kv namespace than the one you'd use in production. Please create a new kv namespace with "wrangler kv:namespace create <name> --preview" and add its id as preview_id to the kv_namespace "${binding}" in your wrangler.toml`
+              ); // Ugh, I really don't like this message very much
+            }
+            return {
+              binding,
+              id: preview_id,
+            };
+          }
+        ),
+        // Use a copy of combinedVars since we're modifying it later
+        vars: getVarsForDev(config),
+        wasm_modules: config.wasm_modules,
+        text_blobs: config.text_blobs,
+        data_blobs: config.data_blobs,
+        durable_objects: config.durable_objects,
+        r2_buckets: config.r2_buckets?.map(
+          ({ binding, preview_bucket_name, bucket_name: _bucket_name }) => {
+            // same idea as kv namespace preview id,
+            // same copy-on-write TODO
+            if (!preview_bucket_name) {
+              throw new Error(
+                `In development, you should use a separate r2 bucket than the one you'd use in production. Please create a new r2 bucket with "wrangler r2 bucket create <name>" and add its name as preview_bucket_name to the r2_buckets "${binding}" in your wrangler.toml`
+              );
+            }
+            return {
+              binding,
+              bucket_name: preview_bucket_name,
+            };
+          }
+        ),
+        services: config.services,
+        unsafe: config.unsafe?.bindings,
+      };
+
+      // mask anything that was overridden in .dev.vars
+      // so that we don't log potential secrets into the terminal
+      const maskedVars = { ...bindings.vars };
+      for (const key of Object.keys(maskedVars)) {
+        if (maskedVars[key] !== config.vars[key]) {
+          // This means it was overridden in .dev.vars
+          // so let's mask it
+          maskedVars[key] = "(hidden)";
+        }
+      }
+
+      // now log all available bindings into the terminal
+      printBindings({
+        ...bindings,
+        vars: maskedVars,
+      });
+
       const { waitUntilExit } = render(
         <Dev
           name={getScriptName(args, config)}
           entry={entry}
           env={args.env}
-          zone={zone}
+          zone={zoneId}
+          host={host}
           rules={getRules(config)}
           legacyEnv={isLegacyEnv(config)}
           minify={args.minify ?? config.minify}
@@ -1056,7 +1196,7 @@ function createCLIParser(argv: string[]) {
           enableLocalPersistence={
             args["experimental-enable-local-persistence"] || false
           }
-          accountId={accountId}
+          accountId={config.account_id}
           assetPaths={getAssetPaths(
             config,
             args.site,
@@ -1081,51 +1221,7 @@ function createCLIParser(argv: string[]) {
             args["compatibility-flags"] || config.compatibility_flags
           }
           usageModel={config.usage_model}
-          bindings={{
-            kv_namespaces: config.kv_namespaces?.map(
-              ({ binding, preview_id, id: _id }) => {
-                // In `dev`, we make folks use a separate kv namespace called
-                // `preview_id` instead of `id` so that they don't
-                // break production data. So here we check that a `preview_id`
-                // has actually been configured.
-                // This whole block of code will be obsoleted in the future
-                // when we have copy-on-write for previews on edge workers.
-                if (!preview_id) {
-                  // TODO: This error has to be a _lot_ better, ideally just asking
-                  // to create a preview namespace for the user automatically
-                  throw new Error(
-                    `In development, you should use a separate kv namespace than the one you'd use in production. Please create a new kv namespace with "wrangler kv:namespace create <name> --preview" and add its id as preview_id to the kv_namespace "${binding}" in your wrangler.toml`
-                  ); // Ugh, I really don't like this message very much
-                }
-                return {
-                  binding,
-                  id: preview_id,
-                };
-              }
-            ),
-            vars: getVarsForDev(config),
-            wasm_modules: config.wasm_modules,
-            text_blobs: config.text_blobs,
-            data_blobs: config.data_blobs,
-            durable_objects: config.durable_objects,
-            r2_buckets: config.r2_buckets?.map(
-              ({ binding, preview_bucket_name, bucket_name: _bucket_name }) => {
-                // same idea as kv namespace preview id,
-                // same copy-on-write TODO
-                if (!preview_bucket_name) {
-                  throw new Error(
-                    `In development, you should use a separate r2 bucket than the one you'd use in production. Please create a new r2 bucket with "wrangler r2 bucket create <name>" and add its name as preview_bucket_name to the r2_buckets "${binding}" in your wrangler.toml`
-                  );
-                }
-                return {
-                  binding,
-                  bucket_name: preview_bucket_name,
-                };
-              }
-            ),
-            services: config.services,
-            unsafe: config.unsafe?.bindings,
-          }}
+          bindings={bindings}
           crons={config.triggers.crons}
         />
       );
@@ -1286,6 +1382,7 @@ function createCLIParser(argv: string[]) {
         args.siteInclude,
         args.siteExclude
       );
+
       await publish({
         config,
         accountId,
@@ -1513,6 +1610,7 @@ function createCLIParser(argv: string[]) {
           rules={getRules(config)}
           env={args.env}
           zone={undefined}
+          host={undefined}
           legacyEnv={isLegacyEnv(config)}
           build={config.build || {}}
           minify={undefined}
@@ -2396,14 +2494,7 @@ function createCLIParser(argv: string[]) {
             }
 
             const accountId = await requireAuth(config);
-            await putKVBulkKeyValue(
-              accountId,
-              namespaceId,
-              content,
-              (index, total) => {
-                logger.log(`Uploaded ${index} of ${total}.`);
-              }
-            );
+            await putKVBulkKeyValue(accountId, namespaceId, content);
 
             logger.log("Success!");
           }
@@ -2493,14 +2584,7 @@ function createCLIParser(argv: string[]) {
 
             const accountId = await requireAuth(config);
 
-            await deleteKVBulkKeyValue(
-              accountId,
-              namespaceId,
-              content,
-              (index, total) => {
-                logger.log(`Deleted ${index} of ${total}.`);
-              }
-            );
+            await deleteKVBulkKeyValue(accountId, namespaceId, content);
 
             logger.log("Success!");
           }
@@ -2682,14 +2766,14 @@ export async function main(argv: string[]): Promise<void> {
       await createCLIParser([...argv, "--help"]).parse();
     } else if (e instanceof ParseError) {
       e.notes.push({
-        text: "\nIf you think this is a bug, please open an issue at: https://github.com/cloudflare/wrangler2/issues/new",
+        text: "\nIf you think this is a bug, please open an issue at: https://github.com/cloudflare/wrangler2/issues/new/choose",
       });
-      logger.error(formatMessage(e));
+      logger.log(formatMessage(e));
     } else {
       logger.error(e instanceof Error ? e.message : e);
       logger.log(
         `${fgGreenColor}%s${resetColor}`,
-        "If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        "If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
       );
     }
     throw e;