wrangler 0.0.0-e928f94 → 0.0.0-e978986

package/src/pages.tsx

@@ -1,24 +1,131 @@
-import type { BuilderCallback } from "yargs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { existsSync, lstatSync, readFileSync } from "fs";
-import { execSync, spawn } from "child_process";
-import { Headers, Request, Response } from "undici";
-import type { MiniflareOptions } from "miniflare";
-import type { RequestInfo, RequestInit } from "@miniflare/core";
-import open from "open";
+/* eslint-disable no-shadow */
+
+import { execSync, spawn } from "node:child_process";
+import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, sep, extname, basename } from "node:path";
+import { cwd } from "node:process";
+import { URL } from "node:url";
+import { hash } from "blake3-wasm";
 import { watch } from "chokidar";
+import { render, Text } from "ink";
+import SelectInput from "ink-select-input";
+import Spinner from "ink-spinner";
+import Table from "ink-table";
+import { getType } from "mime";
+import PQueue from "p-queue";
+import prettyBytes from "pretty-bytes";
+import React from "react";
+import { format as timeagoFormat } from "timeago.js";
+import { File, FormData } from "undici";
+import { buildPlugin } from "../pages/functions/buildPlugin";
+import { buildWorker } from "../pages/functions/buildWorker";
+import { generateConfigFromFileTree } from "../pages/functions/filepath-routing";
+import { writeRoutesModule } from "../pages/functions/routes";
+import { fetchResult } from "./cfetch";
+import { getConfigCache, saveToConfigCache } from "./config-cache";
+import { prompt } from "./dialogs";
+import { FatalError } from "./errors";
+import { logger } from "./logger";
+import { getRequestContextCheckOptions } from "./miniflare-cli/request-context";
+import openInBrowser from "./open-in-browser";
+import { toUrlPath } from "./paths";
+import { requireAuth } from "./user";
+import type { Config } from "../pages/functions/routes";
+import type {
+  Headers as MiniflareHeaders,
+  Request as MiniflareRequest,
+  fetch as miniflareFetch,
+} from "@miniflare/core";
+import type { BuildResult } from "esbuild";
+import type { MiniflareOptions } from "miniflare";
+import type { BuilderCallback, CommandModule } from "yargs";
+
+export type Project = {
+  name: string;
+  subdomain: string;
+  domains: Array<string>;
+  source?: {
+    type: string;
+  };
+  latest_deployment?: {
+    modified_on: string;
+  };
+  created_on: string;
+  production_branch: string;
+};
+
+export type Deployment = {
+  id: string;
+  environment: string;
+  deployment_trigger: {
+    metadata: {
+      commit_hash: string;
+      branch: string;
+    };
+  };
+  url: string;
+  latest_stage: {
+    status: string;
+    ended_on: string;
+  };
+  project_name: string;
+};
 
-type Exit = (message?: string) => undefined;
+export type UploadPayloadFile = {
+  key: string;
+  value: string;
+  metadata: { contentType: string };
+  base64: boolean;
+};
+
+interface PagesConfigCache {
+  account_id?: string;
+  project_name?: string;
+}
+
+const PAGES_CONFIG_CACHE_FILENAME = "pages.json";
+const MAX_BUCKET_SIZE = 50 * 1024 * 1024;
+const MAX_BUCKET_FILE_COUNT = 5000;
+const BULK_UPLOAD_CONCURRENCY = 3;
+const MAX_UPLOAD_ATTEMPTS = 5;
+
+// Defer importing miniflare until we really need it. This takes ~0.5s
+// and also modifies some `stream/web` and `undici` prototypes, so we
+// don't want to do this if pages commands aren't being called.
+
+export const pagesBetaWarning =
+  "🚧 'wrangler pages <command>' is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose";
 
-const isWindows = () => process.platform === "win32";
+const isInPagesCI = !!process.env.CF_PAGES;
+
+const CLEANUP_CALLBACKS: (() => void)[] = [];
+const CLEANUP = () => {
+  CLEANUP_CALLBACKS.forEach((callback) => callback());
+  RUNNING_BUILDERS.forEach((builder) => builder.stop?.());
+};
+
+process.on("SIGINT", () => {
+  CLEANUP();
+  process.exit();
+});
+process.on("SIGTERM", () => {
+  CLEANUP();
+  process.exit();
+});
+
+function isWindows() {
+  return process.platform === "win32";
+}
 
 const SECONDS_TO_WAIT_FOR_PROXY = 5;
 
-const sleep = async (ms: number) =>
+async function sleep(ms: number) {
   await new Promise((resolve) => setTimeout(resolve, ms));
+}
 
-const getPids = (pid: number) => {
+function getPids(pid: number) {
   const pids: number[] = [pid];
   let command: string, regExp: RegExp;
 
@@ -43,9 +150,9 @@ const getPids = (pid: number) => {
   } catch {}
 
   return pids;
-};
+}
 
-const getPort = (pid: number) => {
+function getPort(pid: number) {
   let command: string, regExp: RegExp;
 
   if (isWindows()) {
@@ -66,31 +173,28 @@ const getPort = (pid: number) => {
     const match = matches[0];
     if (match) return parseInt(match[1]);
   } catch (thrown) {
-    console.error(
+    logger.error(
       `Error scanning for ports of process with PID ${pid}: ${thrown}`
     );
   }
-};
+}
 
-const spawnProxyProcess = async ({
+async function spawnProxyProcess({
   port,
   command,
 }: {
   port?: number;
   command: (string | number)[];
-}) => {
-  const exit: Exit = (message) => {
-    if (message) console.error(message);
-    if (proxy) proxy.kill();
-    return undefined;
-  };
-
-  if (command.length === 0)
-    return exit(
-      "Must specify a directory of static assets to serve or a command to run."
+}): Promise<void | number> {
+  if (command.length === 0) {
+    CLEANUP();
+    throw new FatalError(
+      "Must specify a directory of static assets to serve or a command to run.",
+      1
     );
+  }
 
-  console.log(`Running ${command.join(" ")}...`);
+  logger.log(`Running ${command.join(" ")}...`);
   const proxy = spawn(
     command[0].toString(),
     command.slice(1).map((value) => value.toString()),
@@ -102,27 +206,30 @@ const spawnProxyProcess = async ({
       },
     }
   );
+  CLEANUP_CALLBACKS.push(() => {
+    proxy.kill();
+  });
 
   proxy.stdout.on("data", (data) => {
-    console.log(`[proxy]: ${data}`);
+    logger.log(`[proxy]: ${data}`);
   });
 
   proxy.stderr.on("data", (data) => {
-    console.error(`[proxy]: ${data}`);
+    logger.error(`[proxy]: ${data}`);
   });
 
   proxy.on("close", (code) => {
-    console.error(`Proxy exited with status ${code}.`);
+    logger.error(`Proxy exited with status ${code}.`);
   });
 
   // Wait for proxy process to start...
   while (!proxy.pid) {}
 
   if (port === undefined) {
-    console.log(
+    logger.log(
       `Sleeping ${SECONDS_TO_WAIT_FOR_PROXY} seconds to allow proxy process to start before attempting to automatically determine port...`
     );
-    console.log("To skip, specify the proxy port with --proxy.");
+    logger.log("To skip, specify the proxy port with --proxy.");
     await sleep(SECONDS_TO_WAIT_FOR_PROXY * 1000);
 
     port = getPids(proxy.pid)
@@ -130,34 +237,36 @@ const spawnProxyProcess = async ({
       .filter((port) => port !== undefined)[0];
 
     if (port === undefined) {
-      return exit(
-        "Could not automatically determine proxy port. Please specify the proxy port with --proxy."
+      CLEANUP();
+      throw new FatalError(
+        "Could not automatically determine proxy port. Please specify the proxy port with --proxy.",
+        1
       );
     } else {
-      console.log(`Automatically determined the proxy port to be ${port}.`);
+      logger.log(`Automatically determined the proxy port to be ${port}.`);
     }
   }
 
-  return { port, exit };
-};
+  return port;
+}
 
-const escapeRegex = (str: string) => {
+function escapeRegex(str: string) {
   return str.replace(/[-/\\^$*+?.()|[]{}]/g, "\\$&");
-};
+}
 
-export type Replacements = Record<string, string>;
+type Replacements = Record<string, string>;
 
-export const replacer = (str: string, replacements: Replacements) => {
+function replacer(str: string, replacements: Replacements) {
   for (const [replacement, value] of Object.entries(replacements)) {
     str = str.replace(`:${replacement}`, value);
   }
   return str;
-};
+}
 
-export const generateRulesMatcher = <T,>(
+function generateRulesMatcher<T>(
   rules?: Record<string, T>,
   replacer: (match: T, replacements: Replacements) => T = (match) => match
-) => {
+) {
   // TODO: How can you test cross-host rules?
   if (!rules) return () => [];
 
@@ -191,7 +300,7 @@ export const generateRulesMatcher = <T,>(
     T
   ][];
 
-  return ({ request }: { request: Request }) => {
+  return ({ request }: { request: MiniflareRequest }) => {
     const { pathname, host } = new URL(request.url);
 
     return compiledRules
@@ -204,9 +313,9 @@ export const generateRulesMatcher = <T,>(
       })
       .filter((value) => value !== undefined) as T[];
   };
-};
+}
 
-const generateHeadersMatcher = (headersFile: string) => {
+function generateHeadersMatcher(headersFile: string) {
   if (existsSync(headersFile)) {
     const contents = readFileSync(headersFile).toString();
 
@@ -264,7 +373,7 @@ const generateHeadersMatcher = (headersFile: string) => {
       )
     );
 
-    return (request: Request) => {
+    return (request: MiniflareRequest) => {
       const matches = rulesMatcher({
         request,
       });
@@ -273,9 +382,9 @@ const generateHeadersMatcher = (headersFile: string) => {
   } else {
     return () => undefined;
   }
-};
+}
 
-const generateRedirectsMatcher = (redirectsFile: string) => {
+function generateRedirectsMatcher(redirectsFile: string) {
   if (existsSync(redirectsFile)) {
     const contents = readFileSync(redirectsFile).toString();
 
@@ -313,7 +422,7 @@ const generateRedirectsMatcher = (redirectsFile: string) => {
       })
     );
 
-    return (request: Request) => {
+    return (request: MiniflareRequest) => {
       const match = rulesMatcher({
         request,
       })[0];
@@ -322,26 +431,26 @@ const generateRedirectsMatcher = (redirectsFile: string) => {
   } else {
     return () => undefined;
   }
-};
+}
 
-const extractPathname = (
+function extractPathname(
   path = "/",
   includeSearch: boolean,
   includeHash: boolean
-) => {
+) {
   if (!path.startsWith("/")) path = `/${path}`;
   const url = new URL(`//${path}`, "relative://");
   return `${url.pathname}${includeSearch ? url.search : ""}${
     includeHash ? url.hash : ""
   }`;
-};
+}
 
-const validateURL = (
+function validateURL(
   token: string,
   onlyRelative = false,
   includeSearch = false,
   includeHash = false
-) => {
+) {
   const host = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/.exec(token);
   if (host && host.groups && host.groups.host) {
     if (onlyRelative) return;
@@ -362,14 +471,18 @@ const validateURL = (
     }
   }
   return "";
-};
+}
 
-const hasFileExtension = (pathname: string) =>
-  /\/.+\.[a-z0-9]+$/i.test(pathname);
+function hasFileExtension(pathname: string) {
+  return /\/.+\.[a-z0-9]+$/i.test(pathname);
+}
 
-const generateAssetsFetch = async (
+async function generateAssetsFetch(
   directory: string
-): Promise<typeof fetch> => {
+): Promise<typeof miniflareFetch> {
+  // Defer importing miniflare until we really need it
+  const { Headers, Request, Response } = await import("@miniflare/core");
+
   const headersFile = join(directory, "_headers");
   const redirectsFile = join(directory, "_redirects");
   const workerFile = join(directory, "_worker.js");
@@ -399,12 +512,12 @@ const generateAssetsFetch = async (
   }).on("change", (path) => {
     switch (path) {
       case headersFile: {
-        console.log("_headers modified. Re-evaluating...");
+        logger.log("_headers modified. Re-evaluating...");
         headersMatcher = generateHeadersMatcher(headersFile);
         break;
       }
       case redirectsFile: {
-        console.log("_redirects modified. Re-evaluating...");
+        logger.log("_redirects modified. Re-evaluating...");
         redirectsMatcher = generateRedirectsMatcher(redirectsFile);
         break;
       }
@@ -415,12 +528,12 @@ const generateAssetsFetch = async (
     return readFileSync(file);
   };
 
-  const generateResponse = (request: Request) => {
+  const generateResponse = (request: MiniflareRequest) => {
     const url = new URL(request.url);
 
     const deconstructedResponse: {
       status: number;
-      headers: Headers;
+      headers: MiniflareHeaders;
       body?: Buffer;
     } = {
       status: 200,
@@ -466,14 +579,25 @@ const generateAssetsFetch = async (
         if ((asset = getAsset(`${cwd}/404.html`))) {
           deconstructedResponse.status = 404;
           deconstructedResponse.body = serveAsset(asset);
+          deconstructedResponse.headers.set(
+            "Content-Type",
+            getType(asset) || "application/octet-stream"
+          );
           return deconstructedResponse;
         }
       }
 
       if ((asset = getAsset(`/index.html`))) {
         deconstructedResponse.body = serveAsset(asset);
+        deconstructedResponse.headers.set(
+          "Content-Type",
+          getType(asset) || "application/octet-stream"
+        );
         return deconstructedResponse;
       }
+
+      deconstructedResponse.status = 404;
+      return deconstructedResponse;
     };
 
     let asset;
@@ -481,6 +605,10 @@ const generateAssetsFetch = async (
     if (url.pathname.endsWith("/")) {
       if ((asset = getAsset(`${url.pathname}/index.html`))) {
         deconstructedResponse.body = serveAsset(asset);
+        deconstructedResponse.headers.set(
+          "Content-Type",
+          getType(asset) || "application/octet-stream"
+        );
         return deconstructedResponse;
       } else if (
         (asset = getAsset(`${url.pathname.replace(/\/$/, ".html")}`))
@@ -508,6 +636,10 @@ const generateAssetsFetch = async (
         const extensionlessPath = url.pathname.slice(0, -".html".length);
         if (getAsset(extensionlessPath) || extensionlessPath === "/") {
           deconstructedResponse.body = serveAsset(asset);
+          deconstructedResponse.headers.set(
+            "Content-Type",
+            getType(asset) || "application/octet-stream"
+          );
           return deconstructedResponse;
         } else {
           deconstructedResponse.status = 301;
@@ -519,6 +651,10 @@ const generateAssetsFetch = async (
         }
       } else {
         deconstructedResponse.body = serveAsset(asset);
+        deconstructedResponse.headers.set(
+          "Content-Type",
+          getType(asset) || "application/octet-stream"
+        );
         return deconstructedResponse;
       }
     } else if (hasFileExtension(url.pathname)) {
@@ -528,6 +664,10 @@ const generateAssetsFetch = async (
 
     if ((asset = getAsset(`${url.pathname}.html`))) {
       deconstructedResponse.body = serveAsset(asset);
+      deconstructedResponse.headers.set(
+        "Content-Type",
+        getType(asset) || "application/octet-stream"
+      );
       return deconstructedResponse;
     }
 
@@ -545,8 +685,12 @@ const generateAssetsFetch = async (
   };
 
   const attachHeaders = (
-    request: Request,
-    deconstructedResponse: { status: number; headers: Headers; body?: Buffer }
+    request: MiniflareRequest,
+    deconstructedResponse: {
+      status: number;
+      headers: MiniflareHeaders;
+      body?: Buffer;
+    }
   ) => {
     const headers = deconstructedResponse.headers;
     const newHeaders = new Headers({});
@@ -569,7 +713,7 @@ const generateAssetsFetch = async (
     });
   };
 
-  return (async (input, init) => {
+  return async (input, init) => {
     const request = new Request(input, init);
     const deconstructedResponse = generateResponse(request);
     attachHeaders(request, deconstructedResponse);
@@ -584,212 +728,873 @@ const generateAssetsFetch = async (
       headers,
       status: deconstructedResponse.status,
     });
-  }) as any;
-};
+  };
+}
+
+const RUNNING_BUILDERS: BuildResult[] = [];
+
+async function buildFunctions({
+  outfile,
+  outputConfigPath,
+  functionsDirectory,
+  minify = false,
+  sourcemap = false,
+  fallbackService = "ASSETS",
+  watch = false,
+  onEnd,
+  plugin = false,
+  buildOutputDirectory,
+  nodeCompat,
+}: {
+  outfile: string;
+  outputConfigPath?: string;
+  functionsDirectory: string;
+  minify?: boolean;
+  sourcemap?: boolean;
+  fallbackService?: string;
+  watch?: boolean;
+  onEnd?: () => void;
+  plugin?: boolean;
+  buildOutputDirectory?: string;
+  nodeCompat?: boolean;
+}) {
+  RUNNING_BUILDERS.forEach(
+    (runningBuilder) => runningBuilder.stop && runningBuilder.stop()
+  );
 
-export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
-  return yargs.command(
-    "dev [directory] [-- command]",
-    "🧑‍💻 Develop your full-stack Pages application locally",
-    (yargs) => {
-      return yargs
-        .positional("directory", {
+  const routesModule = join(tmpdir(), `./functionsRoutes-${Math.random()}.mjs`);
+  const baseURL = toUrlPath("/");
+
+  const config: Config = await generateConfigFromFileTree({
+    baseDir: functionsDirectory,
+    baseURL,
+  });
+
+  if (outputConfigPath) {
+    writeFileSync(
+      outputConfigPath,
+      JSON.stringify({ ...config, baseURL }, null, 2)
+    );
+  }
+
+  await writeRoutesModule({
+    config,
+    srcDir: functionsDirectory,
+    outfile: routesModule,
+  });
+
+  if (plugin) {
+    RUNNING_BUILDERS.push(
+      await buildPlugin({
+        routesModule,
+        outfile,
+        minify,
+        sourcemap,
+        watch,
+        nodeCompat,
+        onEnd,
+      })
+    );
+  } else {
+    RUNNING_BUILDERS.push(
+      await buildWorker({
+        routesModule,
+        outfile,
+        minify,
+        sourcemap,
+        fallbackService,
+        watch,
+        onEnd,
+        buildOutputDirectory,
+        nodeCompat,
+      })
+    );
+  }
+}
+
+interface CreateDeploymentArgs {
+  directory: string;
+  projectName?: string;
+  branch?: string;
+  commitHash?: string;
+  commitMessage?: string;
+  commitDirty?: boolean;
+}
+
+const createDeployment: CommandModule<
+  CreateDeploymentArgs,
+  CreateDeploymentArgs
+> = {
+  describe: "🆙 Publish a directory of static assets as a Pages deployment",
+  builder: (yargs) => {
+    return yargs
+      .positional("directory", {
+        type: "string",
+        demandOption: true,
+        description: "The directory of static files to upload",
+      })
+      .options({
+        "project-name": {
           type: "string",
-          demandOption: undefined,
-          description: "The directory of static assets to serve",
-        })
-        .positional("command", {
+          description: "The name of the project you want to deploy to",
+        },
+        branch: {
           type: "string",
-          demandOption: undefined,
-          description: "The proxy command to run",
-        })
-        .options({
-          local: {
-            type: "boolean",
-            default: true,
-            description: "Run on my machine",
-          },
-          port: {
-            type: "number",
-            default: 8788,
-            description: "The port to listen on (serve from)",
-          },
-          proxy: {
-            type: "number",
-            description:
-              "The port to proxy (where the static assets are served)",
-          },
-          "script-path": {
-            type: "string",
-            default: "_worker.js",
-            description:
-              "The location of the single Worker script if not using functions",
-          },
-          binding: {
-            type: "array",
-            description: "Bind variable/secret (KEY=VALUE)",
-            alias: "b",
-          },
-          kv: {
-            type: "array",
-            description: "KV namespace to bind",
-            alias: "k",
-          },
-          do: {
-            type: "array",
-            description: "Durable Object to bind (NAME=CLASS)",
-            alias: "o",
-          },
-          // TODO: Miniflare user options
+          description: "The name of the branch you want to deploy to",
+        },
+        "commit-hash": {
+          type: "string",
+          description: "The SHA to attach to this deployment",
+        },
+        "commit-message": {
+          type: "string",
+          description: "The commit message to attach to this deployment",
+        },
+        "commit-dirty": {
+          type: "boolean",
+          description:
+            "Whether or not the workspace should be considered dirty for this deployment",
+        },
+      })
+      .epilogue(pagesBetaWarning);
+  },
+  handler: async ({
+    directory,
+    projectName,
+    branch,
+    commitHash,
+    commitMessage,
+    commitDirty,
+  }) => {
+    if (!directory) {
+      throw new FatalError("Must specify a directory.", 1);
+    }
+
+    const config = getConfigCache<PagesConfigCache>(
+      PAGES_CONFIG_CACHE_FILENAME
+    );
+    const accountId = await requireAuth(config);
+
+    projectName ??= config.project_name;
+
+    const isInteractive = process.stdin.isTTY;
+    if (!projectName && isInteractive) {
+      const projects = (await listProjects({ accountId })).filter(
+        (project) => !project.source
+      );
+
+      let existingOrNew: "existing" | "new" = "new";
+
+      if (projects.length > 0) {
+        existingOrNew = await new Promise<"new" | "existing">((resolve) => {
+          const { unmount } = render(
+            <>
+              <Text>
+                No project selected. Would you like to create one or use an
+                existing project?
+              </Text>
+              <SelectInput
+                items={[
+                  {
+                    key: "new",
+                    label: "Create a new project",
+                    value: "new",
+                  },
+                  {
+                    key: "existing",
+                    label: "Use an existing project",
+                    value: "existing",
+                  },
+                ]}
+                onSelect={async (selected) => {
+                  resolve(selected.value as "new" | "existing");
+                  unmount();
+                }}
+              />
+            </>
+          );
         });
-    },
-    async ({
-      local,
-      directory,
-      port,
-      proxy: requestedProxyPort,
-      "script-path": singleWorkerScriptPath,
-      binding: bindings = [],
-      kv: kvs = [],
-      do: durableObjects = [],
-      "--": remaining = [],
-    }) => {
-      if (!local) {
-        console.error("Only local mode is supported at the moment.");
-        return;
       }
 
-      const functionsDirectory = "./functions";
-      const usingFunctions = existsSync(functionsDirectory);
+      switch (existingOrNew) {
+        case "existing": {
+          projectName = await new Promise((resolve) => {
+            const { unmount } = render(
+              <>
+                <Text>Select a project:</Text>
+                <SelectInput
+                  items={projects.map((project) => ({
+                    key: project.name,
+                    label: project.name,
+                    value: project,
+                  }))}
+                  onSelect={async (selected) => {
+                    resolve(selected.value.name);
+                    unmount();
+                  }}
+                />
+              </>
+            );
+          });
+          break;
+        }
+        case "new": {
+          projectName = await prompt("Enter the name of your new project:");
 
-      const command = remaining as (string | number)[];
+          if (!projectName) {
+            throw new FatalError("Must specify a project name.", 1);
+          }
 
-      let proxyPort: number | undefined;
-      let exit: Exit = (message) => {
-        console.error(message);
-        return undefined;
-      };
+          let isGitDir = true;
+          try {
+            execSync(`git rev-parse --is-inside-work-tree`, {
+              stdio: "ignore",
+            });
+          } catch (err) {
+            isGitDir = false;
+          }
 
-      if (directory === undefined) {
-        const proxy = await spawnProxyProcess({
-          port: requestedProxyPort,
-          command,
-        });
-        if (proxy === undefined) return undefined;
+          const productionBranch = await prompt(
+            "Enter the production branch name:",
+            "text",
+            isGitDir
+              ? execSync(`git rev-parse --abbrev-ref HEAD`).toString().trim()
+              : "production"
+          );
 
-        exit = proxy.exit;
-        proxyPort = proxy.port;
+          if (!productionBranch) {
+            throw new FatalError("Must specify a production branch.", 1);
+          }
 
-        process.on("SIGINT", () => exit());
-        process.on("SIGTERM", () => exit());
+          await fetchResult<Project>(`/accounts/${accountId}/pages/projects`, {
+            method: "POST",
+            body: JSON.stringify({
+              name: projectName,
+              production_branch: productionBranch,
+            }),
+          });
+
+          saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+            account_id: accountId,
+            project_name: projectName,
+          });
+
+          logger.log(`✨ Successfully created the '${projectName}' project.`);
+          break;
+        }
       }
+    }
 
-      let miniflareArgs: MiniflareOptions = {};
+    if (!projectName) {
+      throw new FatalError("Must specify a project name.", 1);
+    }
 
-      if (usingFunctions) {
-        const scriptPath = join(tmpdir(), "./functionsWorker.js");
-        miniflareArgs = {
-          scriptPath,
-          buildWatchPaths: [functionsDirectory],
-          buildCommand: `npx @cloudflare/pages-functions-compiler build ${functionsDirectory} --outfile ${scriptPath}`,
-        };
-      } else {
-        const scriptPath =
-          directory !== undefined
-            ? join(directory, singleWorkerScriptPath)
-            : singleWorkerScriptPath;
+    // We infer git info by default is not passed in
 
-        if (!existsSync(scriptPath)) {
-          return exit(
-            `No Worker script found at ${scriptPath}. Please either create a functions directory or create a single Worker at ${scriptPath}.`
-          );
+    let isGitDir = true;
+    try {
+      execSync(`git rev-parse --is-inside-work-tree`, {
+        stdio: "ignore",
+      });
+    } catch (err) {
+      isGitDir = false;
+    }
+
+    let isGitDirty = false;
+
+    if (isGitDir) {
+      try {
+        isGitDirty = Boolean(
+          execSync(`git status --porcelain`).toString().length
+        );
+
+        if (!branch) {
+          branch = execSync(`git rev-parse --abbrev-ref HEAD`)
+            .toString()
+            .trim();
+        }
+
+        if (!commitHash) {
+          commitHash = execSync(`git rev-parse HEAD`).toString().trim();
+        }
+
+        if (!commitMessage) {
+          commitMessage = execSync(`git show -s --format=%B ${commitHash}`)
+            .toString()
+            .trim();
         }
+      } catch (err) {}
 
-        miniflareArgs = {
-          scriptPath,
-        };
+      if (isGitDirty && !commitDirty) {
+        logger.warn(
+          `Warning: Your working directory is a git repo and has uncommitted changes\nTo silence this warning, pass in --commit-dirty=true`
+        );
       }
 
-      const { Miniflare, Log, LogLevel } = await import("miniflare");
-      const { fetch } = await import("@miniflare/core");
+      if (commitDirty === undefined) {
+        commitDirty = isGitDirty;
+      }
+    }
 
-      class MiniflareLogger extends Log {
-        logWithLevel(level: number, message: string) {
-          if (level <= this.level) {
-            switch (level) {
-              case LogLevel.NONE: {
-                break;
-              }
-              case LogLevel.ERROR: {
-                console.error(message);
-                break;
-              }
-              case LogLevel.WARN: {
-                console.warn(message);
-                break;
-              }
-              case LogLevel.INFO: {
-                console.info(message);
-                break;
-              }
-              case LogLevel.DEBUG: {
-                console.debug(message);
-                break;
-              }
-              case LogLevel.VERBOSE: {
-                console.debug(message);
-                break;
-              }
+    let builtFunctions: string | undefined = undefined;
+    const functionsDirectory = join(cwd(), "functions");
+    if (existsSync(functionsDirectory)) {
+      const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`);
+
+      await new Promise((resolve) =>
+        buildFunctions({
+          outfile,
+          functionsDirectory,
+          onEnd: () => resolve(null),
+          buildOutputDirectory: dirname(outfile),
+        })
+      );
+
+      builtFunctions = readFileSync(outfile, "utf-8");
+    }
+
+    type FileContainer = {
+      content: string;
+      contentType: string;
+      sizeInBytes: number;
+      hash: string;
+    };
+
+    const IGNORE_LIST = [
+      "_worker.js",
+      "_redirects",
+      "_headers",
+      ".DS_Store",
+      "node_modules",
+      ".git",
+    ];
+
+    const walk = async (
+      dir: string,
+      fileMap: Map<string, FileContainer> = new Map(),
+      depth = 0
+    ) => {
+      const files = await readdir(dir);
+
+      await Promise.all(
+        files.map(async (file) => {
+          const filepath = join(dir, file);
+          const filestat = await stat(filepath);
+
+          if (IGNORE_LIST.includes(file)) {
+            return;
+          }
+
+          if (filestat.isSymbolicLink()) {
+            return;
+          }
+
+          if (filestat.isDirectory()) {
+            fileMap = await walk(filepath, fileMap, depth + 1);
+          } else {
+            let name;
+            if (depth) {
+              name = filepath.split(sep).slice(1).join("/");
+            } else {
+              name = file;
+            }
+
+            // TODO: Move this to later so we don't hold as much in memory
+            const fileContent = await readFile(filepath);
+
+            const base64Content = fileContent.toString("base64");
+            const extension = extname(basename(name)).substring(1);
+
+            if (filestat.size > 25 * 1024 * 1024) {
+              throw new Error(
+                `Error: Pages only supports files up to ${prettyBytes(
+                  25 * 1024 * 1024
+                )} in size\n${name} is ${prettyBytes(filestat.size)} in size`
+              );
             }
+
+            fileMap.set(name, {
+              content: base64Content,
+              contentType: getType(name) || "application/octet-stream",
+              sizeInBytes: filestat.size,
+              hash: hash(base64Content + extension)
+                .toString("hex")
+                .slice(0, 32),
+            });
           }
+        })
+      );
+
+      return fileMap;
+    };
+
+    const fileMap = await walk(directory);
+
+    if (fileMap.size > 20000) {
+      throw new FatalError(
+        `Error: Pages only supports up to 20,000 files in a deployment. Ensure you have specified your build output directory correctly.`,
+        1
+      );
+    }
+
+    const files = [...fileMap.values()];
+
+    const { jwt } = await fetchResult<{ jwt: string }>(
+      `/accounts/${accountId}/pages/projects/${projectName}/upload-token`
+    );
+
+    const start = Date.now();
+
+    const missingHashes = await fetchResult<string[]>(
+      `/pages/assets/check-missing`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${jwt}`,
+        },
+        body: JSON.stringify({
+          hashes: files.map(({ hash }) => hash),
+        }),
+      }
+    );
+
+    const sortedFiles = files
+      .filter((file) => missingHashes.includes(file.hash))
+      .sort((a, b) => b.sizeInBytes - a.sizeInBytes);
+
+    // Start with a few buckets so small projects still get
+    // the benefit of multiple upload streams
+    const buckets: {
+      files: FileContainer[];
+      remainingSize: number;
+    }[] = new Array(BULK_UPLOAD_CONCURRENCY).fill(null).map(() => ({
+      files: [],
+      remainingSize: MAX_BUCKET_SIZE,
+    }));
+
+    let bucketOffset = 0;
+    for (const file of sortedFiles) {
+      let inserted = false;
+
+      for (let i = 0; i < buckets.length; i++) {
+        // Start at a different bucket for each new file
+        const bucket = buckets[(i + bucketOffset) % buckets.length];
+        if (
+          bucket.remainingSize >= file.sizeInBytes &&
+          bucket.files.length < MAX_BUCKET_FILE_COUNT
+        ) {
+          bucket.files.push(file);
+          bucket.remainingSize -= file.sizeInBytes;
+          inserted = true;
+          break;
         }
+      }
 
-        log(message: string) {}
+      if (!inserted) {
+        buckets.push({
+          files: [file],
+          remainingSize: MAX_BUCKET_SIZE - file.sizeInBytes,
+        });
+      }
+      bucketOffset++;
+    }
 
-        error(message: Error) {
-          this.logWithLevel(
-            LogLevel.ERROR,
-            message.stack ? message.stack : `${message}`
-          );
+    let counter = fileMap.size - sortedFiles.length;
+    const { rerender, unmount } = render(
+      <Progress done={counter} total={fileMap.size} />
+    );
+
+    const queue = new PQueue({ concurrency: BULK_UPLOAD_CONCURRENCY });
+
+    for (const bucket of buckets) {
+      // Don't upload empty buckets (can happen for tiny projects)
+      if (bucket.files.length === 0) continue;
+
+      const payload: UploadPayloadFile[] = bucket.files.map((file) => ({
+        key: file.hash,
+        value: file.content,
+        metadata: {
+          contentType: file.contentType,
+        },
+        base64: true,
+      }));
+
+      let attempts = 0;
+      const doUpload = async (): Promise<void> => {
+        try {
+          return await fetchResult(`/pages/assets/upload`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${jwt}`,
+            },
+            body: JSON.stringify(payload),
+          });
+        } catch (e) {
+          if (attempts < MAX_UPLOAD_ATTEMPTS) {
+            // Linear backoff, 0 second first time, then 1 second etc.
+            await new Promise((resolve) =>
+              setTimeout(resolve, attempts++ * 1000)
+            );
+            return doUpload();
+          } else {
+            throw e;
+          }
         }
+      };
+
+      queue.add(() =>
+        doUpload().then(
+          () => {
+            counter += bucket.files.length;
+            rerender(<Progress done={counter} total={fileMap.size} />);
+          },
+          (error) => {
+            return Promise.reject(
+              new FatalError(
+                "Failed to upload files. Please try again.",
+                error.code || 1
+              )
+            );
+          }
+        )
+      );
+    }
+
+    await queue.onIdle();
+
+    unmount();
+
+    const uploadMs = Date.now() - start;
+
+    logger.log(
+      `✨ Success! Uploaded ${fileMap.size} files ${formatTime(uploadMs)}\n`
+    );
+
+    const formData = new FormData();
+
+    formData.append(
+      "manifest",
+      JSON.stringify(
+        Object.fromEntries(
+          [...fileMap.entries()].map(([fileName, file]) => [
+            `/${fileName}`,
+            file.hash,
+          ])
+        )
+      )
+    );
+
+    if (branch) {
+      formData.append("branch", branch);
+    }
+
+    if (commitMessage) {
+      formData.append("commit_message", commitMessage);
+    }
+
+    if (commitHash) {
+      formData.append("commit_hash", commitHash);
+    }
+
+    if (commitDirty !== undefined) {
+      formData.append("commit_dirty", commitDirty);
+    }
+
+    let _headers: string | undefined,
+      _redirects: string | undefined,
+      _workerJS: string | undefined;
+
+    try {
+      _headers = readFileSync(join(directory, "_headers"), "utf-8");
+    } catch {}
+
+    try {
+      _redirects = readFileSync(join(directory, "_redirects"), "utf-8");
+    } catch {}
+
+    try {
+      _workerJS = readFileSync(join(directory, "_worker.js"), "utf-8");
+    } catch {}
+
+    if (_headers) {
+      formData.append("_headers", new File([_headers], "_headers"));
+    }
+
+    if (_redirects) {
+      formData.append("_redirects", new File([_redirects], "_redirects"));
+    }
+
+    if (builtFunctions) {
+      formData.append("_worker.js", new File([builtFunctions], "_worker.js"));
+    } else if (_workerJS) {
+      formData.append("_worker.js", new File([_workerJS], "_worker.js"));
+    }
+
+    const deploymentResponse = await fetchResult<Deployment>(
+      `/accounts/${accountId}/pages/projects/${projectName}/deployments`,
+      {
+        method: "POST",
+        body: formData,
       }
+    );
+
+    saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+      account_id: accountId,
+      project_name: projectName,
+    });
+
+    logger.log(
+      `✨ Deployment complete! Take a peek over at ${deploymentResponse.url}`
+    );
+  },
+};
 
-      const miniflare = new Miniflare({
+export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
+  return yargs
+    .command(
+      "dev [directory] [-- command..]",
+      "🧑‍💻 Develop your full-stack Pages application locally",
+      (yargs) => {
+        return yargs
+          .positional("directory", {
+            type: "string",
+            demandOption: undefined,
+            description: "The directory of static assets to serve",
+          })
+          .positional("command", {
+            type: "string",
+            demandOption: undefined,
+            description: "The proxy command to run",
+          })
+          .options({
+            local: {
+              type: "boolean",
+              default: true,
+              description: "Run on my machine",
+            },
+            port: {
+              type: "number",
+              default: 8788,
+              description: "The port to listen on (serve from)",
+            },
+            proxy: {
+              type: "number",
+              description:
+                "The port to proxy (where the static assets are served)",
+            },
+            "script-path": {
+              type: "string",
+              default: "_worker.js",
+              description:
+                "The location of the single Worker script if not using functions",
+            },
+            binding: {
+              type: "array",
+              description: "Bind variable/secret (KEY=VALUE)",
+              alias: "b",
+            },
+            kv: {
+              type: "array",
+              description: "KV namespace to bind",
+              alias: "k",
+            },
+            do: {
+              type: "array",
+              description: "Durable Object to bind (NAME=CLASS)",
+              alias: "o",
+            },
+            "live-reload": {
+              type: "boolean",
+              default: false,
+              description: "Auto reload HTML pages when change is detected",
+            },
+            "node-compat": {
+              describe: "Enable node.js compatibility",
+              default: false,
+              type: "boolean",
+              hidden: true,
+            },
+            // TODO: Miniflare user options
+          })
+          .epilogue(pagesBetaWarning);
+      },
+      async ({
+        local,
+        directory,
         port,
-        watch: true,
-        modules: true,
+        proxy: requestedProxyPort,
+        "script-path": singleWorkerScriptPath,
+        binding: bindings = [],
+        kv: kvs = [],
+        do: durableObjects = [],
+        "live-reload": liveReload,
+        "node-compat": nodeCompat,
+        _: [_pages, _dev, ...remaining],
+      }) => {
+        // Beta message for `wrangler pages <commands>` usage
+        logger.log(pagesBetaWarning);
+
+        if (!local) {
+          logger.error("Only local mode is supported at the moment.");
+          return;
+        }
 
-        log: new MiniflareLogger(LogLevel.ERROR),
+        const functionsDirectory = "./functions";
+        const usingFunctions = existsSync(functionsDirectory);
 
-        kvNamespaces: kvs.map((kv) => kv.toString()),
+        const command = remaining as (string | number)[];
 
-        durableObjects: Object.fromEntries(
-          durableObjects.map((durableObject) =>
-            durableObject.toString().split("=")
-          )
-        ),
+        let proxyPort: number | void;
 
-        bindings: {
-          // User bindings
-          ...Object.fromEntries(
-            bindings.map((binding) => binding.toString().split("="))
+        if (directory === undefined) {
+          proxyPort = await spawnProxyProcess({
+            port: requestedProxyPort,
+            command,
+          });
+          if (proxyPort === undefined) return undefined;
+        }
+
+        let miniflareArgs: MiniflareOptions = {};
+
+        let scriptReadyResolve: () => void;
+        const scriptReadyPromise = new Promise<void>(
+          (resolve) => (scriptReadyResolve = resolve)
+        );
+
+        if (usingFunctions) {
+          const outfile = join(
+            tmpdir(),
+            `./functionsWorker-${Math.random()}.js`
+          );
+
+          if (nodeCompat) {
+            console.warn(
+              "Enabling node.js compatibility mode for builtins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
+            );
+          }
+
+          logger.log(`Compiling worker to "${outfile}"...`);
+
+          try {
+            await buildFunctions({
+              outfile,
+              functionsDirectory,
+              sourcemap: true,
+              watch: true,
+              onEnd: () => scriptReadyResolve(),
+              buildOutputDirectory: directory,
+              nodeCompat,
+            });
+          } catch {}
+
+          watch([functionsDirectory], {
+            persistent: true,
+            ignoreInitial: true,
+          }).on("all", async () => {
+            await buildFunctions({
+              outfile,
+              functionsDirectory,
+              sourcemap: true,
+              watch: true,
+              onEnd: () => scriptReadyResolve(),
+              buildOutputDirectory: directory,
+              nodeCompat,
+            });
+          });
+
+          miniflareArgs = {
+            scriptPath: outfile,
+          };
+        } else {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          scriptReadyResolve!();
+
+          const scriptPath =
+            directory !== undefined
+              ? join(directory, singleWorkerScriptPath)
+              : singleWorkerScriptPath;
+
+          if (existsSync(scriptPath)) {
+            miniflareArgs = {
+              scriptPath,
+            };
+          } else {
+            logger.log("No functions. Shimming...");
+            miniflareArgs = {
+              // cfFetch sets the `cf` object that a function could expect
+              // If there are no functions, there's no reason to set this up (and not make that network call)
+              cfFetch: false,
+              // TODO: The fact that these request/response hacks are necessary is ridiculous.
+              // We need to eliminate them from env.ASSETS.fetch (not sure if just local or prod as well)
+              script: `
+            export default {
+              async fetch(request, env, context) {
+                const response = await env.ASSETS.fetch(request.url, request)
+                return new Response(response.body, response)
+              }
+            }`,
+            };
+          }
+        }
+
+        // Defer importing miniflare until we really need it
+        const { Miniflare, Log, LogLevel } = await import("miniflare");
+        const { Response, fetch } = await import("@miniflare/core");
+
+        // Wait for esbuild to finish building before starting Miniflare.
+        // This must be before the call to `new Miniflare`, as that will
+        // asynchronously start loading the script. `await startServer()`
+        // internally just waits for that promise to resolve.
+        await scriptReadyPromise;
+
+        // `assetsFetch()` will only be called if there is `proxyPort` defined.
+        // We only define `proxyPort`, above, when there is no `directory` defined.
+        const assetsFetch =
+          directory !== undefined
+            ? await generateAssetsFetch(directory)
+            : invalidAssetsFetch;
+
+        const requestContextCheckOptions =
+          await getRequestContextCheckOptions();
+
+        const miniflare = new Miniflare({
+          port,
+          watch: true,
+          modules: true,
+
+          log: new Log(LogLevel.ERROR, { prefix: "pages" }),
+          logUnhandledRejections: true,
+          sourceMap: true,
+
+          kvNamespaces: kvs.map((kv) => kv.toString()),
+
+          durableObjects: Object.fromEntries(
+            durableObjects.map((durableObject) =>
+              durableObject.toString().split("=")
+            )
           ),
 
+          // User bindings
+          bindings: {
+            ...Object.fromEntries(
+              bindings
+                .map((binding) => binding.toString().split("="))
+                .map(([key, ...values]) => [key, values.join("=")])
+            ),
+          },
+
           // env.ASSETS.fetch
-          ASSETS: {
-            fetch: async (
-              input: RequestInfo,
-              init?: RequestInit | undefined
-            ) => {
+          serviceBindings: {
+            async ASSETS(request: MiniflareRequest) {
               if (proxyPort) {
                 try {
-                  let request = new Request(input as any, init);
                   const url = new URL(request.url);
-                  url.host = `127.0.0.1:${proxyPort}`;
-                  request = new Request(url.toString(), request);
-                  return await fetch(request);
+                  url.host = `localhost:${proxyPort}`;
+                  return await fetch(url, request);
                 } catch (thrown) {
-                  console.error(`Could not proxy request: ${thrown}`);
+                  logger.error(`Could not proxy request: ${thrown}`);
 
                   // TODO: Pretty error page
                   return new Response(
@@ -799,11 +1604,9 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
                 }
               } else {
                 try {
-                  return await (
-                    await generateAssetsFetch(directory)
-                  )(input as any, init as any);
+                  return await assetsFetch(request);
                 } catch (thrown) {
-                  console.error(`Could not serve static asset: ${thrown}`);
+                  logger.error(`Could not serve static asset: ${thrown}`);
 
                   // TODO: Pretty error page
                   return new Response(
@@ -814,30 +1617,411 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
               }
             },
           },
-        },
 
-        kvPersist: true,
-        durableObjectsPersist: true,
-        cachePersist: true,
+          kvPersist: true,
+          durableObjectsPersist: true,
+          cachePersist: true,
+          liveReload,
 
-        ...miniflareArgs,
-      });
+          ...requestContextCheckOptions,
+          ...miniflareArgs,
+        });
 
-      const server = await miniflare.startServer();
-      console.log(`Serving at http://127.0.0.1:${port}/`);
+        try {
+          // `startServer` might throw if user code contains errors
+          const server = await miniflare.startServer();
+          logger.log(`Serving at http://localhost:${port}/`);
 
-      if (process.env.BROWSER !== "none") {
-        open(`http://127.0.0.1:${port}/`);
+          if (process.env.BROWSER !== "none") {
+            await openInBrowser(`http://localhost:${port}/`);
+          }
+
+          if (directory !== undefined && liveReload) {
+            watch([directory], {
+              persistent: true,
+              ignoreInitial: true,
+            }).on("all", async () => {
+              await miniflare.reload();
+            });
+          }
+
+          CLEANUP_CALLBACKS.push(() => {
+            server.close();
+            miniflare.dispose().catch((err) => miniflare.log.error(err));
+          });
+        } catch (e) {
+          miniflare.log.error(e as Error);
+          CLEANUP();
+          throw new FatalError("Could not start Miniflare.", 1);
+        }
       }
+    )
+    .command("functions", false, (yargs) =>
+      // we hide this command from help output because
+      // it's not meant to be used directly right now
+      yargs.command(
+        "build [directory]",
+        "Compile a folder of Cloudflare Pages Functions into a single Worker",
+        (yargs) =>
+          yargs
+            .positional("directory", {
+              type: "string",
+              default: "functions",
+              description: "The directory of Pages Functions",
+            })
+            .options({
+              outfile: {
+                type: "string",
+                default: "_worker.js",
+                description: "The location of the output Worker script",
+              },
+              "output-config-path": {
+                type: "string",
+                description: "The location for the output config file",
+              },
+              minify: {
+                type: "boolean",
+                default: false,
+                description: "Minify the output Worker script",
+              },
+              sourcemap: {
+                type: "boolean",
+                default: false,
+                description:
+                  "Generate a sourcemap for the output Worker script",
+              },
+              "fallback-service": {
+                type: "string",
+                default: "ASSETS",
+                description:
+                  "The service to fallback to at the end of the `next` chain. Setting to '' will fallback to the global `fetch`.",
+              },
+              watch: {
+                type: "boolean",
+                default: false,
+                description:
+                  "Watch for changes to the functions and automatically rebuild the Worker script",
+              },
+              plugin: {
+                type: "boolean",
+                default: false,
+                description: "Build a plugin rather than a Worker script",
+              },
+              "build-output-directory": {
+                type: "string",
+                description: "The directory to output static assets to",
+              },
+              "node-compat": {
+                describe: "Enable node.js compatibility",
+                default: false,
+                type: "boolean",
+                hidden: true,
+              },
+            })
+            .epilogue(pagesBetaWarning),
+        async ({
+          directory,
+          outfile,
+          "output-config-path": outputConfigPath,
+          minify,
+          sourcemap,
+          fallbackService,
+          watch,
+          plugin,
+          "build-output-directory": buildOutputDirectory,
+          "node-compat": nodeCompat,
+        }) => {
+          if (!isInPagesCI) {
+            // Beta message for `wrangler pages <commands>` usage
+            logger.log(pagesBetaWarning);
+          }
 
-      process.on("SIGINT", () => {
-        server.close();
-        miniflare.dispose();
-      });
-      process.on("SIGTERM", () => {
-        server.close();
-        miniflare.dispose();
-      });
-    }
+          if (nodeCompat) {
+            console.warn(
+              "Enabling node.js compatibility mode for builtins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
+            );
+          }
+
+          buildOutputDirectory ??= dirname(outfile);
+
+          await buildFunctions({
+            outfile,
+            outputConfigPath,
+            functionsDirectory: directory,
+            minify,
+            sourcemap,
+            fallbackService,
+            watch,
+            plugin,
+            buildOutputDirectory,
+            nodeCompat,
+          });
+        }
+      )
+    )
+    .command("project", "⚡️ Interact with your Pages projects", (yargs) =>
+      yargs
+        .command(
+          "list",
+          "List your Cloudflare Pages projects",
+          (yargs) => yargs.epilogue(pagesBetaWarning),
+          async () => {
+            const config = getConfigCache<PagesConfigCache>(
+              PAGES_CONFIG_CACHE_FILENAME
+            );
+
+            const accountId = await requireAuth(config);
+
+            const projects: Array<Project> = await listProjects({ accountId });
+
+            const data = projects.map((project) => {
+              return {
+                "Project Name": project.name,
+                "Project Domains": `${project.domains.join(", ")}`,
+                "Git Provider": project.source ? "Yes" : "No",
+                "Last Modified": project.latest_deployment
+                  ? timeagoFormat(project.latest_deployment.modified_on)
+                  : timeagoFormat(project.created_on),
+              };
+            });
+
+            saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+              account_id: accountId,
+            });
+
+            render(<Table data={data}></Table>);
+          }
+        )
+        .command(
+          "create [project-name]",
+          "Create a new Cloudflare Pages project",
+          (yargs) =>
+            yargs
+              .positional("project-name", {
+                type: "string",
+                demandOption: true,
+                description: "The name of your Pages project",
+              })
+              .options({
+                "production-branch": {
+                  type: "string",
+                  description:
+                    "The name of the production branch of your project",
+                },
+              })
+              .epilogue(pagesBetaWarning),
+          async ({ productionBranch, projectName }) => {
+            const config = getConfigCache<PagesConfigCache>(
+              PAGES_CONFIG_CACHE_FILENAME
+            );
+            const accountId = await requireAuth(config);
+
+            const isInteractive = process.stdin.isTTY;
+            if (!projectName && isInteractive) {
+              projectName = await prompt("Enter the name of your new project:");
+            }
+
+            if (!projectName) {
+              throw new FatalError("Must specify a project name.", 1);
+            }
+
+            if (!productionBranch && isInteractive) {
+              let isGitDir = true;
+              try {
+                execSync(`git rev-parse --is-inside-work-tree`, {
+                  stdio: "ignore",
+                });
+              } catch (err) {
+                isGitDir = false;
+              }
+
+              productionBranch = await prompt(
+                "Enter the production branch name:",
+                "text",
+                isGitDir
+                  ? execSync(`git rev-parse --abbrev-ref HEAD`)
+                      .toString()
+                      .trim()
+                  : "production"
+              );
+            }
+
+            if (!productionBranch) {
+              throw new FatalError("Must specify a production branch.", 1);
+            }
+
+            const { subdomain } = await fetchResult<Project>(
+              `/accounts/${accountId}/pages/projects`,
+              {
+                method: "POST",
+                body: JSON.stringify({
+                  name: projectName,
+                  production_branch: productionBranch,
+                }),
+              }
+            );
+
+            saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+              account_id: accountId,
+              project_name: projectName,
+            });
+
+            logger.log(
+              `✨ Successfully created the '${projectName}' project. It will be available at https://${subdomain}/ once you create your first deployment.`
+            );
+            logger.log(
+              `To deploy a folder of assets, run 'wrangler pages publish [directory]'.`
+            );
+          }
+        )
+        .epilogue(pagesBetaWarning)
+    )
+    .command(
+      "deployment",
+      "🚀 Interact with the deployments of a project",
+      (yargs) =>
+        yargs
+          .command(
+            "list",
+            "List deployments in your Cloudflare Pages project",
+            (yargs) =>
+              yargs
+                .options({
+                  "project-name": {
+                    type: "string",
+                    description:
+                      "The name of the project you would like to list deployments for",
+                  },
+                })
+                .epilogue(pagesBetaWarning),
+            async ({ projectName }) => {
+              const config = getConfigCache<PagesConfigCache>(
+                PAGES_CONFIG_CACHE_FILENAME
+              );
+              const accountId = await requireAuth(config);
+
+              projectName ??= config.project_name;
+
+              const isInteractive = process.stdin.isTTY;
+              if (!projectName && isInteractive) {
+                const projects = await listProjects({ accountId });
+                projectName = await new Promise((resolve) => {
+                  const { unmount } = render(
+                    <>
+                      <Text>Select a project:</Text>
+                      <SelectInput
+                        items={projects.map((project) => ({
+                          key: project.name,
+                          label: project.name,
+                          value: project,
+                        }))}
+                        onSelect={async (selected) => {
+                          resolve(selected.value.name);
+                          unmount();
+                        }}
+                      />
+                    </>
+                  );
+                });
+              }
+
+              if (!projectName) {
+                throw new FatalError("Must specify a project name.", 1);
+              }
+
+              const deployments: Array<Deployment> = await fetchResult(
+                `/accounts/${accountId}/pages/projects/${projectName}/deployments`
+              );
+
+              const titleCase = (word: string) =>
+                word.charAt(0).toUpperCase() + word.slice(1);
+
+              const shortSha = (sha: string) => sha.slice(0, 7);
+
+              const getStatus = (deployment: Deployment) => {
+                // Return a pretty time since timestamp if successful otherwise the status
+                if (deployment.latest_stage.status === `success`) {
+                  return timeagoFormat(deployment.latest_stage.ended_on);
+                }
+                return titleCase(deployment.latest_stage.status);
+              };
+
+              const data = deployments.map((deployment) => {
+                return {
+                  Environment: titleCase(deployment.environment),
+                  Branch: deployment.deployment_trigger.metadata.branch,
+                  Source: shortSha(
+                    deployment.deployment_trigger.metadata.commit_hash
+                  ),
+                  Deployment: deployment.url,
+                  Status: getStatus(deployment),
+                  // TODO: Use a url shortener
+                  Build: `https://dash.cloudflare.com/${accountId}/pages/view/${deployment.project_name}/${deployment.id}`,
+                };
+              });
+
+              saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+                account_id: accountId,
+              });
+
+              render(<Table data={data}></Table>);
+            }
+          )
+          .command({
+            command: "create [directory]",
+            ...createDeployment,
+          } as CommandModule)
+          .epilogue(pagesBetaWarning)
+    )
+    .command({
+      command: "publish [directory]",
+      ...createDeployment,
+    } as CommandModule);
+};
+
+const invalidAssetsFetch: typeof miniflareFetch = () => {
+  throw new Error(
+    "Trying to fetch assets directly when there is no `directory` option specified, and not in `local` mode."
   );
 };
+
+const listProjects = async ({
+  accountId,
+}: {
+  accountId: string;
+}): Promise<Array<Project>> => {
+  const pageSize = 10;
+  let page = 1;
+  const results = [];
+  while (results.length % pageSize === 0) {
+    const json: Array<Project> = await fetchResult(
+      `/accounts/${accountId}/pages/projects`,
+      {},
+      new URLSearchParams({
+        per_page: pageSize.toString(),
+        page: page.toString(),
+      })
+    );
+    page++;
+    results.push(...json);
+    if (json.length < pageSize) {
+      break;
+    }
+  }
+  return results;
+};
+
+function formatTime(duration: number) {
+  return `(${(duration / 1000).toFixed(2)} sec)`;
+}
+
+function Progress({ done, total }: { done: number; total: number }) {
+  return (
+    <>
+      <Text>
+        <Spinner type="earth" />
+        {` Uploading... (${done}/${total})\n`}
+      </Text>
+    </>
+  );
+}