wrangler 0.0.0-e88a54e → 0.0.0-e95e5a0

package/src/sites.tsx

@@ -9,6 +9,7 @@ import {
   putBulkKeyValue,
   deleteBulkKeyValue,
 } from "./kv";
+import { logger } from "./logger";
 import type { Config } from "./config";
 import type { KeyValue } from "./kv";
 import type { XXHashAPI } from "xxhash-wasm";
@@ -82,7 +83,7 @@ async function createKVNamespaceIfNotAlreadyExisting(
 
   // else we make the namespace
   const id = await createNamespace(accountId, title);
-  console.log(`🌀 Created namespace for Workers Site "${title}"`);
+  logger.log(`🌀 Created namespace for Workers Site "${title}"`);
 
   return {
     created: true,
@@ -105,7 +106,8 @@ export async function syncAssets(
   accountId: string,
   scriptName: string,
   siteAssets: AssetPaths | undefined,
-  preview: boolean
+  preview: boolean,
+  dryRun: boolean | undefined
 ): Promise<{
   manifest: { [filePath: string]: string } | undefined;
   namespace: string | undefined;
@@ -114,17 +116,23 @@ export async function syncAssets(
     return { manifest: undefined, namespace: undefined };
   }
 
+  if (dryRun) {
+    logger.log("(Note: doing a dry run, not uploading or deleting anything.)");
+    return { manifest: undefined, namespace: undefined };
+  }
+
   const title = `__${scriptName}-workers_sites_assets${
     preview ? "_preview" : ""
   }`;
+
   const { id: namespace } = await createKVNamespaceIfNotAlreadyExisting(
     title,
     accountId
   );
 
   // let's get all the keys in this namespace
-  const result = await listNamespaceKeys(accountId, namespace);
-  const keys = new Set(result.map((x) => x.name));
+  const namespaceKeysResponse = await listNamespaceKeys(accountId, namespace);
+  const namespaceKeys = new Set(namespaceKeysResponse.map((x) => x.name));
 
   const manifest: Record<string, string> = {};
   const toUpload: KeyValue[] = [];
@@ -147,42 +155,47 @@ export async function syncAssets(
     }
 
     await validateAssetSize(absAssetFile, assetFile);
-    console.log(`reading ${assetFile}...`);
+    logger.log(`Reading ${assetFile}...`);
     const content = await readFile(absAssetFile, "base64");
 
     const assetKey = hashAsset(hasher, assetFile, content);
     validateAssetKey(assetKey);
 
     // now put each of the files into kv
-    if (!keys.has(assetKey)) {
-      console.log(`uploading as ${assetKey}...`);
+    if (!namespaceKeys.has(assetKey)) {
+      logger.log(`Uploading as ${assetKey}...`);
       toUpload.push({
         key: assetKey,
         value: content,
         base64: true,
       });
     } else {
-      console.log(`skipping - already uploaded`);
+      logger.log(`Skipping - already uploaded.`);
     }
 
     // remove the key from the set so we know what we've already uploaded
-    keys.delete(assetKey);
+    namespaceKeys.delete(assetKey);
     manifest[path.relative(siteAssets.assetDirectory, absAssetFile)] = assetKey;
   }
 
   // keys now contains all the files we're deleting
-  for (const key of keys) {
-    console.log(`deleting ${key} from the asset store...`);
+  for (const key of namespaceKeys) {
+    logger.log(`Deleting ${key} from the asset store...`);
   }
 
   await Promise.all([
     // upload all the new assets
     putBulkKeyValue(accountId, namespace, toUpload, () => {}),
     // delete all the unused assets
-    deleteBulkKeyValue(accountId, namespace, Array.from(keys), () => {}),
+    deleteBulkKeyValue(
+      accountId,
+      namespace,
+      Array.from(namespaceKeys),
+      () => {}
+    ),
   ]);
 
-  console.log("↗️  Done syncing assets");
+  logger.log("↗️  Done syncing assets");
 
   return { manifest, namespace };
 }
@@ -264,7 +277,7 @@ export function getAssetPaths(
   assetDirectory = config.site?.bucket,
   includePatterns = config.site?.include ?? [],
   excludePatterns = config.site?.exclude ?? []
-): undefined | AssetPaths {
+): AssetPaths | undefined {
   const baseDirectory = path.resolve(
     path.dirname(config.configPath ?? "wrangler.toml")
   );

package/src/tail/index.ts

@@ -161,7 +161,7 @@ export type TailEventMessage = {
    * Any logs sent out by the worker
    */
   logs: {
-    message: unknown;
+    message: unknown[];
     level: string; // TODO: make this a union of possible values
     timestamp: number;
   }[];
@@ -179,7 +179,7 @@ export type TailEventMessage = {
    * Until workers-types exposes individual types for export, we'll have
    * to just re-define these types ourselves.
    */
-  event: RequestEvent | ScheduledEvent;
+  event: RequestEvent | ScheduledEvent | undefined | null;
 };
 
 /**

package/src/tail/printing.ts

@@ -1,3 +1,4 @@
+import { logger } from "../logger";
 import type { RequestEvent, ScheduledEvent, TailEventMessage } from ".";
 import type { Outcome } from "./filters";
 import type WebSocket from "ws";
@@ -12,25 +13,29 @@ export function prettyPrintLogs(data: WebSocket.RawData): void {
     ).toLocaleString();
     const outcome = prettifyOutcome(eventMessage.outcome);
 
-    console.log(`"${cronPattern}" @ ${datetime} - ${outcome}`);
+    logger.log(`"${cronPattern}" @ ${datetime} - ${outcome}`);
   } else {
-    const requestMethod = eventMessage.event.request.method.toUpperCase();
-    const url = eventMessage.event.request.url;
+    const requestMethod = eventMessage.event?.request.method.toUpperCase();
+    const url = eventMessage.event?.request.url;
     const outcome = prettifyOutcome(eventMessage.outcome);
     const datetime = new Date(eventMessage.eventTimestamp).toLocaleString();
 
-    console.log(`${requestMethod} ${url} - ${outcome} @ ${datetime}`);
+    logger.log(
+      url
+        ? `${requestMethod} ${url} - ${outcome} @ ${datetime}`
+        : `[missing request] - ${outcome} @ ${datetime}`
+    );
   }
 
   if (eventMessage.logs.length > 0) {
     eventMessage.logs.forEach(({ level, message }) => {
-      console.log(`  (${level}) ${message}`);
+      logger.log(`  (${level})`, ...message);
     });
   }
 
   if (eventMessage.exceptions.length > 0) {
     eventMessage.exceptions.forEach(({ name, message }) => {
-      console.error(`  ${name}: ${message}`);
+      logger.error(`  ${name}:`, message);
     });
   }
 }
@@ -40,9 +45,9 @@ export function jsonPrintLogs(data: WebSocket.RawData): void {
 }
 
 function isScheduledEvent(
-  event: RequestEvent | ScheduledEvent
+  event: RequestEvent | ScheduledEvent | undefined | null
 ): event is ScheduledEvent {
-  return "cron" in event;
+  return Boolean(event && "cron" in event);
 }
 
 function prettifyOutcome(outcome: Outcome): string {

package/src/update-check.ts

@@ -0,0 +1,19 @@
+import chalk from "chalk";
+import checkForUpdate from "update-check";
+import pkg from "../package.json";
+
+export async function updateCheck(): Promise<string> {
+  let update = null;
+  try {
+    // default cache for update check is 1 day
+    update = await checkForUpdate(pkg, {
+      distTag: pkg.version.startsWith("0.0.0") ? "beta" : "latest",
+    });
+  } catch (err) {
+    // ignore error
+  }
+
+  if (update) return `(update available ${chalk.green(update.latest)})`;
+
+  return "";
+}

package/src/user.tsx

@@ -220,9 +220,11 @@ import Table from "ink-table";
 import React from "react";
 import { fetch } from "undici";
 import { getCloudflareApiBaseUrl } from "./cfetch";
+import { purgeConfigCaches } from "./config-cache";
 import { getEnvironmentVariableFactory } from "./environment-variables";
+import { logger } from "./logger";
 import openInBrowser from "./open-in-browser";
-import { readFileSync } from "./parse";
+import { parseTOML, readFileSync } from "./parse";
 import type { Item as SelectInputItem } from "ink-select-input/build/SelectInput";
 import type { ParsedUrlQuery } from "node:querystring";
 import type { Response } from "undici";
@@ -345,7 +347,7 @@ let LocalState: State = getAuthTokens();
 /**
  * Compute the current auth tokens.
  */
-function getAuthTokens(): AuthTokens {
+function getAuthTokens(config?: UserAuthConfig): AuthTokens {
   // get refreshToken/accessToken from fs if exists
   try {
     // if the environment variable is available, use that
@@ -361,7 +363,7 @@ function getAuthTokens(): AuthTokens {
 
     // otherwise try loading from the user auth config file.
     const { oauth_token, refresh_token, expiration_time, api_token } =
-      readAuthConfigFile();
+      config || readAuthConfigFile();
 
     if (oauth_token) {
       return {
@@ -384,20 +386,44 @@ function getAuthTokens(): AuthTokens {
 
 /**
  * Run the initialisation of the auth state, in the case that something changed.
+ *
+ * This runs automatically whenever `writeAuthConfigFile` is run, so generally
+ * you won't need to call it yourself.
  */
-export function reinitialiseAuthTokens(): void {
-  LocalState = getAuthTokens();
+export function reinitialiseAuthTokens(): void;
+
+/**
+ * Reinitialise auth state from an in-memory config, skipping
+ * over the part where we write a file and then read it back into memory
+ */
+export function reinitialiseAuthTokens(config: UserAuthConfig): void;
+
+export function reinitialiseAuthTokens(config?: UserAuthConfig): void {
+  LocalState = getAuthTokens(config);
 }
 
 export function getAPIToken(): string | undefined {
   if (LocalState.apiToken) {
-    console.warn(
+    logger.warn(
       "It looks like you have used Wrangler 1's `config` command to login with an API token.\n" +
         "This is no longer supported in the current version of Wrangler.\n" +
         "If you wish to authenticate via an API token then please set the `CLOUDFLARE_API_TOKEN` environment variable."
     );
   }
-  return LocalState.accessToken?.value;
+
+  const localAPIToken = getCloudflareAPITokenFromEnv();
+
+  if (
+    !process.stdout.isTTY &&
+    !localAPIToken &&
+    !LocalState.accessToken?.value
+  ) {
+    throw new Error(
+      "In a non-interactive environment, it's necessary to set a CLOUDFLARE_API_TOKEN environment variable for wrangler to work. Please go to https://developers.cloudflare.com/api/tokens/create/ for instructions on how to create an api token, and assign its value to CLOUDFLARE_API_TOKEN."
+    );
+  }
+
+  return localAPIToken ?? LocalState.accessToken?.value;
 }
 
 interface AccessContext {
@@ -584,8 +610,8 @@ function isReturningFromAuthServer(query: ParsedUrlQuery): boolean {
 
   const stateQueryParam = query.state;
   if (stateQueryParam !== state.stateQueryParam) {
-    console.warn(
-      "state query string parameter doesn't match the one sent! Possible malicious activity somewhere."
+    logger.warn(
+      "Received query string parameter doesn't match the one sent! Possible malicious activity somewhere."
     );
     throw new ErrorInvalidReturnedStateParam();
   }
@@ -610,8 +636,8 @@ export async function getAuthURL(scopes = ScopeKeys): Promise<string> {
     `?response_type=code&` +
     `client_id=${encodeURIComponent(CLIENT_ID)}&` +
     `redirect_uri=${encodeURIComponent(CALLBACK_URL)}&` +
-    // @ts-expect-error we add offline_access manually
-    `scope=${encodeURIComponent(scopes.concat("offline_access").join(" "))}&` +
+    // we add offline_access manually for every request
+    `scope=${encodeURIComponent([...scopes, "offline_access"].join(" "))}&` +
     `state=${stateQueryParam}&` +
     `code_challenge=${encodeURIComponent(codeChallenge)}&` +
     `code_challenge_method=S256`
@@ -634,7 +660,7 @@ type TokenResponse =
  */
 async function exchangeRefreshTokenForAccessToken(): Promise<AccessContext> {
   if (!LocalState.refreshToken) {
-    console.warn("No refresh token is present.");
+    logger.warn("No refresh token is present.");
   }
 
   const body =
@@ -649,8 +675,27 @@ async function exchangeRefreshTokenForAccessToken(): Promise<AccessContext> {
       "Content-Type": "application/x-www-form-urlencoded",
     },
   });
+
   if (response.status >= 400) {
-    throw await response.json();
+    let tokenExchangeResErr = undefined;
+
+    try {
+      tokenExchangeResErr = await response.text();
+      tokenExchangeResErr = JSON.parse(tokenExchangeResErr);
+    } catch (e) {
+      // If it can't parse to JSON ignore the error
+    }
+
+    if (tokenExchangeResErr !== undefined) {
+      // We will throw the parsed error if it parsed correctly, otherwise we throw an unknown error.
+      throw typeof tokenExchangeResErr === "string"
+        ? new Error(tokenExchangeResErr)
+        : tokenExchangeResErr;
+    } else {
+      throw new ErrorUnknown(
+        "Failed to parse Error from exchangeRefreshTokenForAccessToken"
+      );
+    }
   } else {
     try {
       const json = (await response.json()) as TokenResponse;
@@ -687,18 +732,6 @@ async function exchangeRefreshTokenForAccessToken(): Promise<AccessContext> {
       };
       return accessContext;
     } catch (error) {
-      switch (error) {
-        case "invalid_grant":
-          console.warn(
-            "Expired! Auth code or refresh token needs to be renewed."
-          );
-          // alert("Redirecting to auth server to obtain a new auth grant code.");
-          // TODO: return refreshAuthCodeOrRefreshToken();
-          break;
-        default:
-          console.error(error);
-          break;
-      }
       if (typeof error === "string") {
         throw toErrorClass(error);
       } else {
@@ -715,9 +748,9 @@ async function exchangeAuthCodeForAccessToken(): Promise<AccessContext> {
   const { authorizationCode, codeVerifier = "" } = LocalState;
 
   if (!codeVerifier) {
-    console.warn("No code verifier is being sent.");
+    logger.warn("No code verifier is being sent.");
   } else if (!authorizationCode) {
-    console.warn("No authorization grant code is being passed.");
+    logger.warn("No authorization grant code is being passed.");
   }
 
   const body =
@@ -738,7 +771,7 @@ async function exchangeAuthCodeForAccessToken(): Promise<AccessContext> {
     const { error } = (await response.json()) as { error: string };
     // .catch((_) => ({ error: "invalid_json" }));
     if (error === "invalid_grant") {
-      console.log("Expired! Auth code or refresh token needs to be renewed.");
+      logger.log("Expired! Auth code or refresh token needs to be renewed.");
       // alert("Redirecting to auth server to obtain a new auth grant code.");
       // TODO: return refreshAuthCodeOrRefreshToken();
     }
@@ -832,6 +865,10 @@ function generateRandomState(lengthOfState: number): string {
     .join("");
 }
 
+/**
+ * Writes a a wrangler config file (auth credentials) to disk,
+ * and updates the user auth state with the new credentials.
+ */
 export function writeAuthConfigFile(config: UserAuthConfig) {
   mkdirSync(path.join(os.homedir(), ".wrangler/config/"), {
     recursive: true,
@@ -841,10 +878,12 @@ export function writeAuthConfigFile(config: UserAuthConfig) {
     TOML.stringify(config as TOML.JsonMap),
     { encoding: "utf-8" }
   );
+
+  reinitialiseAuthTokens();
 }
 
-function readAuthConfigFile(): UserAuthConfig {
-  const toml = TOML.parse(
+export function readAuthConfigFile(): UserAuthConfig {
+  const toml = parseTOML(
     readFileSync(path.join(os.homedir(), USER_AUTH_CONFIG_FILE))
   );
   return toml;
@@ -864,21 +903,29 @@ export async function loginOrRefreshIfRequired(
     // If we are not interactive, we cannot ask the user to login
     return isInteractive && (await login());
   } else if (isAccessTokenExpired()) {
-    return await refreshToken();
+    // We're logged in, but the refresh token seems to have expired,
+    // so let's try to refresh it
+    const didRefresh = await refreshToken();
+    if (didRefresh) {
+      // The token was refreshed, so we're done here
+      return true;
+    } else {
+      // If the refresh token isn't valid, then we ask the user to login again
+      return isInteractive && (await login());
+    }
   } else {
     return true;
   }
 }
 
 export async function login(props?: LoginProps): Promise<boolean> {
-  console.log("Attempting to login via OAuth...");
+  logger.log("Attempting to login via OAuth...");
   const urlToOpen = await getAuthURL(props?.scopes);
-  await openInBrowser(urlToOpen);
   let server: http.Server;
   let loginTimeoutHandle: NodeJS.Timeout;
   const timerPromise = new Promise<boolean>((resolve) => {
     loginTimeoutHandle = setTimeout(() => {
-      console.error(
+      logger.error(
         "Timed out waiting for authorization code, please try again."
       );
       server.close();
@@ -914,7 +961,7 @@ export async function login(props?: LoginProps): Promise<boolean> {
               res.end(() => {
                 finish(false);
               });
-              console.log(
+              logger.error(
                 "Error: Consent denied. You must grant consent to Wrangler in order to login.\n" +
                   "If you don't want to do this consider passing an API token via the `CLOUDFLARE_API_TOKEN` environment variable"
               );
@@ -943,7 +990,9 @@ export async function login(props?: LoginProps): Promise<boolean> {
             res.end(() => {
               finish(true);
             });
-            console.log(`Successfully logged in.`);
+            logger.log(`Successfully logged in.`);
+
+            purgeConfigCaches();
 
             return;
           }
@@ -954,6 +1003,8 @@ export async function login(props?: LoginProps): Promise<boolean> {
     server.listen(8976);
   });
 
+  await openInBrowser(urlToOpen);
+
   return Promise.race([timerPromise, loginPromise]);
 }
 
@@ -978,7 +1029,6 @@ async function refreshToken(): Promise<boolean> {
     writeAuthConfigFile({ oauth_token, expiration_time, refresh_token });
     return true;
   } catch (err) {
-    console.error(err);
     return false;
   }
 }
@@ -986,7 +1036,7 @@ async function refreshToken(): Promise<boolean> {
 export async function logout(): Promise<void> {
   if (!LocalState.accessToken) {
     if (!LocalState.refreshToken) {
-      console.log("Not logged in, exiting...");
+      logger.log("Not logged in, exiting...");
       return;
     }
 
@@ -1003,7 +1053,7 @@ export async function logout(): Promise<void> {
       },
     });
     await response.text(); // blank text? would be nice if it was something meaningful
-    console.log(
+    logger.log(
       "💁  Wrangler is configured with an OAuth token. The token has been successfully revoked"
     );
   }
@@ -1021,11 +1071,11 @@ export async function logout(): Promise<void> {
   });
   await response.text(); // blank text? would be nice if it was something meaningful
   rmSync(path.join(os.homedir(), USER_AUTH_CONFIG_FILE));
-  console.log(`Successfully logged out.`);
+  logger.log(`Successfully logged out.`);
 }
 
 export function listScopes(message = "💁 Available scopes:"): void {
-  console.log(message);
+  logger.log(message);
   const data = ScopeKeys.map((scope: Scope) => ({
     Scope: scope,
     Description: Scopes[scope],
@@ -1090,6 +1140,11 @@ export async function getAccountId(
             .join("\n")
       );
     }
+  } else {
+    if (!isInteractive)
+      throw new Error(
+        `Failed to automatically retrieve account IDs for the logged in user. In a non-interactive environment, it is mandatory to specify an account ID, either by assigning its value to CLOUDFLARE_ACCOUNT_ID, or as \`account_id\` in your \`wrangler.toml\` file.`
+      );
   }
   return accountId;
 }
@@ -1116,3 +1171,23 @@ export function ChooseAccount(props: {
     </>
   );
 }
+
+/**
+ * Ensure that a user is logged in, and a valid account_id is available.
+ */
+export async function requireAuth(config: {
+  account_id?: string;
+}): Promise<string> {
+  const isInteractive = process.stdin.isTTY;
+  const loggedIn = await loginOrRefreshIfRequired(isInteractive);
+  if (!loggedIn) {
+    // didn't login, let's just quit
+    throw new Error("Did not login, quitting...");
+  }
+  const accountId = config.account_id || (await getAccountId(isInteractive));
+  if (!accountId) {
+    throw new Error("No account id found, quitting...");
+  }
+
+  return accountId;
+}

package/src/whoami.tsx

@@ -2,10 +2,11 @@ import { Text, render } from "ink";
 import Table from "ink-table";
 import React from "react";
 import { fetchListResult, fetchResult } from "./cfetch";
+import { logger } from "./logger";
 import { getAPIToken } from "./user";
 
 export async function whoami() {
-  console.log("Getting User settings...");
+  logger.log("Getting User settings...");
   const user = await getUserInfo();
   render(<WhoAmI user={user}></WhoAmI>);
 }

package/src/worker.ts

@@ -75,7 +75,7 @@ interface CfKvNamespace {
 }
 
 /**
- * A binding to a wasm module (in service worker format)
+ * A binding to a wasm module (in service-worker format)
  */
 
 interface CfWasmModuleBindings {
@@ -83,13 +83,21 @@ interface CfWasmModuleBindings {
 }
 
 /**
- * A binding to a text blob (in service worker format)
+ * A binding to a text blob (in service-worker format)
  */
 
 interface CfTextBlobBindings {
   [key: string]: string;
 }
 
+/**
+ * A binding to a data blob (in service-worker format)
+ */
+
+interface CfDataBlobBindings {
+  [key: string]: string;
+}
+
 /**
  * A Durable Object.
  */
@@ -137,7 +145,7 @@ export interface CfWorkerInit {
   /**
    * The list of additional modules.
    */
-  modules: undefined | CfModule[];
+  modules: CfModule[] | undefined;
   /**
    * All the bindings
    */
@@ -146,14 +154,15 @@ export interface CfWorkerInit {
     kv_namespaces: CfKvNamespace[] | undefined;
     wasm_modules: CfWasmModuleBindings | undefined;
     text_blobs: CfTextBlobBindings | undefined;
+    data_blobs: CfDataBlobBindings | undefined;
     durable_objects: { bindings: CfDurableObject[] } | undefined;
     r2_buckets: CfR2Bucket[] | undefined;
     unsafe: CfUnsafeBinding[] | undefined;
   };
-  migrations: undefined | CfDurableObjectMigrations;
+  migrations: CfDurableObjectMigrations | undefined;
   compatibility_date: string | undefined;
-  compatibility_flags: undefined | string[];
-  usage_model: undefined | "bundled" | "unbound";
+  compatibility_flags: string[] | undefined;
+  usage_model: "bundled" | "unbound" | undefined;
 }
 
 export interface CfWorkerContext {