wrangler 0.0.0-ece06ea → 0.0.0-ed4f2ef

package/src/user.tsx

@@ -1,6 +1,6 @@
 /* Based heavily on code from https://github.com/BitySA/oauth2-auth-code-pkce */
 
-/* 
+/*
 
                                  Apache License
                            Version 2.0, January 2004
@@ -205,25 +205,44 @@
    limitations under the License.
   */
 
-import React from "react";
-import { render } from "ink";
-import Table from "ink-table";
-import SelectInput from "ink-select-input";
-import fetch from "node-fetch";
+import assert from "node:assert";
 import { webcrypto as crypto } from "node:crypto";
-import { TextEncoder } from "node:util";
-import open from "open";
-import url from "node:url";
+import { writeFileSync, mkdirSync, rmSync } from "node:fs";
 import http from "node:http";
-import { readFile, writeFile, rm, mkdir } from "node:fs/promises";
-import path from "node:path";
-import process from "node:process";
 import os from "node:os";
+import path from "node:path";
+import url from "node:url";
+import { TextEncoder } from "node:util";
 import TOML from "@iarna/toml";
-import assert from "node:assert";
+import { render, Text } from "ink";
+import SelectInput from "ink-select-input";
+import Table from "ink-table";
+import React from "react";
+import { fetch } from "undici";
+import { getCloudflareApiBaseUrl } from "./cfetch";
+import { getEnvironmentVariableFactory } from "./environment-variables";
+import openInBrowser from "./open-in-browser";
+import { readFileSync } from "./parse";
+import type { Config } from "./config";
+import type { Item as SelectInputItem } from "ink-select-input/build/SelectInput";
 import type { ParsedUrlQuery } from "node:querystring";
-import { CF_API_BASE_URL } from "./cfetch";
-import type { Response } from "node-fetch";
+import type { Response } from "undici";
+
+/**
+ * Try to read the API token from the environment.
+ */
+const getCloudflareAPITokenFromEnv = getEnvironmentVariableFactory({
+  variableName: "CLOUDFLARE_API_TOKEN",
+  deprecatedName: "CF_API_TOKEN",
+});
+
+/**
+ * Try to read the account ID from the environment.
+ */
+const getCloudflareAccountIdFromEnv = getEnvironmentVariableFactory({
+  variableName: "CLOUDFLARE_ACCOUNT_ID",
+  deprecatedName: "CF_ACCOUNT_ID",
+});
 
 /**
  * An implementation of rfc6749#section-4.1 and rfc7636.
@@ -234,17 +253,45 @@ interface PKCECodes {
   codeVerifier: string;
 }
 
-interface State {
-  accessToken?: AccessToken; // persist
+/**
+ * The module level state of the authentication flow.
+ */
+interface State extends AuthTokens {
   authorizationCode?: string;
   codeChallenge?: string;
   codeVerifier?: string;
   hasAuthCodeBeenExchangedForAccessToken?: boolean;
-  refreshToken?: RefreshToken; // persist
   stateQueryParam?: string;
   scopes?: Scope[];
 }
 
+/**
+ * The tokens related to authentication.
+ */
+interface AuthTokens {
+  accessToken?: AccessToken;
+  refreshToken?: RefreshToken;
+  /** @deprecated - this field was only provided by the deprecated `wrangler1 config` command. */
+  apiToken?: string;
+}
+
+/**
+ * The path to the config file that holds user authentication data,
+ * relative to the user's home directory.
+ */
+export const USER_AUTH_CONFIG_FILE = ".wrangler/config/default.toml";
+
+/**
+ * The data that may be read from the `USER_CONFIG_FILE`.
+ */
+export interface UserAuthConfig {
+  oauth_token?: string;
+  refresh_token?: string;
+  expiration_time?: string;
+  /** @deprecated - this field was only provided by the deprecated `wrangler1 config` command. */
+  api_token?: string;
+}
+
 interface RefreshToken {
   value: string;
 }
@@ -254,38 +301,39 @@ interface AccessToken {
   expiry: string;
 }
 
-type Scope =
-  | "account:read"
-  | "user:read"
-  | "workers:write"
-  | "workers_kv:write"
-  | "workers_routes:write"
-  | "workers_scripts:write"
-  | "workers_tail:read"
-  | "zone:read"
-  | "offline_access"; // this should be included by default
-
-const Scopes: Scope[] = [
-  "account:read",
-  "user:read",
-  "workers:write",
-  "workers_kv:write",
-  "workers_routes:write",
-  "workers_scripts:write",
-  "workers_tail:read",
-  "zone:read",
-];
-
-const ScopeDescriptions = [
-  "See your account info such as account details, analytics, and memberships.",
-  "See your user info such as name, email address, and account memberships.",
-  "See and change Cloudflare Workers data such as zones, KV storage, namespaces, scripts, and routes.",
-  "See and change Cloudflare Workers KV Storage data such as keys and namespaces.",
-  "See and change Cloudflare Workers data such as filters and routes.",
-  "See and change Cloudflare Workers scripts, durable objects, subdomains, triggers, and tail data.",
-  "See Cloudflare Workers tail and script data.",
-  "Grants read level access to account zone.",
-];
+const Scopes = {
+  "account:read":
+    "See your account info such as account details, analytics, and memberships.",
+  "user:read":
+    "See your user info such as name, email address, and account memberships.",
+  "workers:write":
+    "See and change Cloudflare Workers data such as zones, KV storage, namespaces, scripts, and routes.",
+  "workers_kv:write":
+    "See and change Cloudflare Workers KV Storage data such as keys and namespaces.",
+  "workers_routes:write":
+    "See and change Cloudflare Workers data such as filters and routes.",
+  "workers_scripts:write":
+    "See and change Cloudflare Workers scripts, durable objects, subdomains, triggers, and tail data.",
+  "workers_tail:read": "See Cloudflare Workers tail and script data.",
+  "pages:write":
+    "See and change Cloudflare Pages projects, settings and deployments.",
+  "zone:read": "Grants read level access to account zone.",
+} as const;
+
+/**
+ * The possible keys for a Scope.
+ *
+ * "offline_access" is automatically included.
+ */
+type Scope = keyof typeof Scopes;
+
+const ScopeKeys = Object.keys(Scopes) as Scope[];
+
+export function validateScopeKeys(
+  scopes: string[]
+): scopes is typeof ScopeKeys {
+  return scopes.every((scope) => scope in Scopes);
+}
 
 const CLIENT_ID = "54d11594-84e4-41aa-b438-e81b8fa78ee7";
 const AUTH_URL = "https://dash.cloudflare.com/oauth2/auth";
@@ -293,63 +341,74 @@ const TOKEN_URL = "https://dash.cloudflare.com/oauth2/token";
 const CALLBACK_URL = "http://localhost:8976/oauth/callback";
 const REVOKE_URL = "https://dash.cloudflare.com/oauth2/revoke";
 
-const LocalState: State = {};
-let initialised = false;
+let LocalState: State = getAuthTokens();
 
-// we do this because we have some async stuff
-// TODO: this should just happen in the top level
-// abd we should fiure out how to do top level await
-export async function initialise(): Promise<void> {
-  // get refreshtoken/accesstoken from fs if exists
+/**
+ * Compute the current auth tokens.
+ */
+function getAuthTokens(config?: UserAuthConfig): AuthTokens {
+  // get refreshToken/accessToken from fs if exists
   try {
-    // if CF_API_TOKEN available, use that
-    if (process.env.CF_API_TOKEN) {
-      LocalState.accessToken = {
-        value: process.env.CF_API_TOKEN,
-        expiry: "3021-12-31T23:59:59+00:00",
+    // if the environment variable is available, use that
+    const apiTokenFromEnv = getCloudflareAPITokenFromEnv();
+    if (apiTokenFromEnv) {
+      return {
+        accessToken: {
+          value: apiTokenFromEnv,
+          expiry: "3021-12-31T23:59:59+00:00",
+        },
       };
-      initialised = true;
-      return;
     }
 
-    const toml = TOML.parse(
-      await readFile(path.join(os.homedir(), ".wrangler/config/default.toml"), {
-        encoding: "utf-8",
-      })
-    );
-    const { oauth_token, refresh_token, expiration_time } = toml as {
-      oauth_token: string;
-      refresh_token: string;
-      expiration_time: string;
-    };
+    // otherwise try loading from the user auth config file.
+    const { oauth_token, refresh_token, expiration_time, api_token } =
+      config || readAuthConfigFile();
+
     if (oauth_token) {
-      LocalState.accessToken = { value: oauth_token, expiry: expiration_time };
-    }
-    if (refresh_token) {
-      LocalState.refreshToken = { value: refresh_token };
+      return {
+        accessToken: {
+          value: oauth_token,
+          // If there is no `expiration_time` field then set it to an old date, to cause it to expire immediately.
+          expiry: expiration_time ?? "2000-01-01:00:00:00+00:00",
+        },
+        refreshToken: { value: refresh_token ?? "" },
+      };
+    } else if (api_token) {
+      return { apiToken: api_token };
+    } else {
+      return {};
     }
-  } catch (err) {
-    // no config yet, let's chill
-    // console.error(err);
+  } catch {
+    return {};
   }
-  initialised = true;
 }
 
-// ugh. TODO: see fix from above.
-function throwIfNotInitialised() {
-  if (initialised === false) {
-    throw new Error(
-      "did you forget to call initialise() from the user module?"
-    );
-  }
+/**
+ * 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;
+
+/**
+ * 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 {
-  if (process.env.CF_API_TOKEN) {
-    return process.env.CF_API_TOKEN;
+export function getAPIToken(): string | undefined {
+  if (LocalState.apiToken) {
+    console.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."
+    );
   }
-
-  throwIfNotInitialised();
   return LocalState.accessToken?.value;
 }
 
@@ -548,7 +607,7 @@ function isReturningFromAuthServer(query: ParsedUrlQuery): boolean {
   return true;
 }
 
-export async function getAuthURL(scopes?: string[]): Promise<string> {
+export async function getAuthURL(scopes = ScopeKeys): Promise<string> {
   const { codeChallenge, codeVerifier } = await generatePKCECodes();
   const stateQueryParam = generateRandomState(RECOMMENDED_STATE_LENGTH);
 
@@ -558,39 +617,44 @@ export async function getAuthURL(scopes?: string[]): Promise<string> {
     stateQueryParam,
   });
 
-  // TODO: verify that the scopes passed are legit
-
   return (
     AUTH_URL +
     `?response_type=code&` +
     `client_id=${encodeURIComponent(CLIENT_ID)}&` +
     `redirect_uri=${encodeURIComponent(CALLBACK_URL)}&` +
-    `scope=${encodeURIComponent(
-      (scopes || 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`
   );
 }
 
+type TokenResponse =
+  | {
+      access_token: string;
+      expires_in: number;
+      refresh_token: string;
+      scope: string;
+    }
+  | {
+      error: string;
+    };
+
 /**
  * Refresh an access token from the remote service.
  */
 async function exchangeRefreshTokenForAccessToken(): Promise<AccessContext> {
-  const { refreshToken } = LocalState;
-
-  if (!refreshToken) {
+  if (!LocalState.refreshToken) {
     console.warn("No refresh token is present.");
   }
 
-  const url = TOKEN_URL;
   const body =
     `grant_type=refresh_token&` +
-    `refresh_token=${refreshToken?.value}&` +
+    `refresh_token=${LocalState.refreshToken?.value}&` +
     `client_id=${CLIENT_ID}`;
 
-  const response = await fetch(url, {
+  const response = await fetch(TOKEN_URL, {
     method: "POST",
     body,
     headers: {
@@ -601,13 +665,12 @@ async function exchangeRefreshTokenForAccessToken(): Promise<AccessContext> {
     throw await response.json();
   } else {
     try {
-      const json = await response.json();
-      const { access_token, expires_in, refresh_token, scope } = json as {
-        access_token: string;
-        expires_in: number;
-        refresh_token: string;
-        scope: string;
-      };
+      const json = (await response.json()) as TokenResponse;
+      if ("error" in json) {
+        throw json.error;
+      }
+
+      const { access_token, expires_in, refresh_token, scope } = json;
       let scopes: Scope[] = [];
 
       const accessToken: AccessToken = {
@@ -617,10 +680,9 @@ async function exchangeRefreshTokenForAccessToken(): Promise<AccessContext> {
       LocalState.accessToken = accessToken;
 
       if (refresh_token) {
-        const refreshToken: RefreshToken = {
+        LocalState.refreshToken = {
           value: refresh_token,
         };
-        LocalState.refreshToken = refreshToken;
       }
 
       if (scope) {
@@ -636,20 +698,24 @@ async function exchangeRefreshTokenForAccessToken(): Promise<AccessContext> {
         refreshToken: LocalState.refreshToken,
       };
       return accessContext;
-    } catch (err) {
-      const error = err?.error || "There was a network error.";
+    } catch (error) {
       switch (error) {
         case "invalid_grant":
-          console.log(
+          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;
       }
-      throw toErrorClass(error);
+      if (typeof error === "string") {
+        throw toErrorClass(error);
+      } else {
+        throw error;
+      }
     }
   }
 }
@@ -666,7 +732,6 @@ async function exchangeAuthCodeForAccessToken(): Promise<AccessContext> {
     console.warn("No authorization grant code is being passed.");
   }
 
-  const url = TOKEN_URL;
   const body =
     `grant_type=authorization_code&` +
     `code=${encodeURIComponent(authorizationCode || "")}&` +
@@ -674,7 +739,7 @@ async function exchangeAuthCodeForAccessToken(): Promise<AccessContext> {
     `client_id=${encodeURIComponent(CLIENT_ID)}&` +
     `code_verifier=${codeVerifier}`;
 
-  const response = await fetch(url, {
+  const response = await fetch(TOKEN_URL, {
     method: "POST",
     body,
     headers: {
@@ -691,13 +756,11 @@ async function exchangeAuthCodeForAccessToken(): Promise<AccessContext> {
     }
     throw toErrorClass(error);
   }
-  const json = await response.json();
-  const { access_token, expires_in, refresh_token, scope } = json as {
-    access_token: string;
-    expires_in: number;
-    refresh_token: string;
-    scope: string;
-  };
+  const json = (await response.json()) as TokenResponse;
+  if ("error" in json) {
+    throw new Error(json.error);
+  }
+  const { access_token, expires_in, refresh_token, scope } = json;
   let scopes: Scope[] = [];
   LocalState.hasAuthCodeBeenExchangedForAccessToken = true;
 
@@ -709,10 +772,9 @@ async function exchangeAuthCodeForAccessToken(): Promise<AccessContext> {
   LocalState.accessToken = accessToken;
 
   if (refresh_token) {
-    const refreshToken: RefreshToken = {
+    LocalState.refreshToken = {
       value: refresh_token,
     };
-    LocalState.refreshToken = refreshToken;
   }
 
   if (scope) {
@@ -782,52 +844,73 @@ function generateRandomState(lengthOfState: number): string {
     .join("");
 }
 
-async function writeToConfigFile(tokenData: AccessContext) {
-  await mkdir(path.join(os.homedir(), ".wrangler/config/"), {
+/**
+ * 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,
   });
-  await writeFile(
-    path.join(os.homedir(), ".wrangler/config/default.toml"),
-    `
-oauth_token = "${tokenData.token?.value || ""}"
-refresh_token = "${tokenData.refreshToken?.value}"
-expiration_time = "${tokenData.token?.expiry}"
-`,
+  writeFileSync(
+    path.join(os.homedir(), USER_AUTH_CONFIG_FILE),
+    TOML.stringify(config as TOML.JsonMap),
     { encoding: "utf-8" }
   );
+
+  reinitialiseAuthTokens();
+}
+
+export function readAuthConfigFile(): UserAuthConfig {
+  const toml = TOML.parse(
+    readFileSync(path.join(os.homedir(), USER_AUTH_CONFIG_FILE))
+  );
+  return toml;
 }
 
 type LoginProps = {
-  scopes?: string[];
+  scopes?: Scope[];
 };
 
-export async function loginOrRefreshIfRequired(): Promise<boolean> {
+export async function loginOrRefreshIfRequired(
+  isInteractive = true
+): Promise<boolean> {
   // TODO: if there already is a token, then try refreshing
   // TODO: ask permission before opening browser
-  if (!LocalState.accessToken) {
-    // not logged in.
-    return await login();
+  if (!getAPIToken()) {
+    // Not logged in.
+    // 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...");
   const urlToOpen = await getAuthURL(props?.scopes);
-  open(urlToOpen);
-  // TODO: log url only if on system where it's unreliable/unavailable
-  // console.log(`💁 Opened ${urlToOpen}`);
-  let server;
-  let loginTimeoutHandle;
+  let server: http.Server;
+  let loginTimeoutHandle: NodeJS.Timeout;
   const timerPromise = new Promise<boolean>((resolve) => {
     loginTimeoutHandle = setTimeout(() => {
-      console.error("Timed out waiting for authorization code.");
+      console.error(
+        "Timed out waiting for authorization code, please try again."
+      );
       server.close();
       clearTimeout(loginTimeoutHandle);
       resolve(false);
-    }, 60000); // wait for 30 seconds for the user to authorize
+    }, 60000); // wait for 60 seconds for the user to authorize
   });
 
   const loginPromise = new Promise<boolean>((resolve, reject) => {
@@ -858,8 +941,9 @@ export async function login(props?: LoginProps): Promise<boolean> {
                 finish(false);
               });
               console.log(
-                "Error: Consent denied. You must grant consent to Wrangler in order to login. If you don't want to do this consider passing an API token with CF_API_TOKEN variable"
-              ); // TODO: implement wrangler config lol
+                "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"
+              );
 
               return;
             } else {
@@ -872,8 +956,12 @@ export async function login(props?: LoginProps): Promise<boolean> {
             finish(false, new ErrorNoAuthCode());
             return;
           } else {
-            const tokenData = await exchangeAuthCodeForAccessToken();
-            await writeToConfigFile(tokenData);
+            const exchange = await exchangeAuthCodeForAccessToken();
+            writeAuthConfigFile({
+              oauth_token: exchange.token?.value ?? "",
+              expiration_time: exchange.token?.expiry,
+              refresh_token: exchange.refreshToken?.value,
+            });
             res.writeHead(307, {
               Location:
                 "https://welcome.developers.workers.dev/wrangler-oauth-consent-granted",
@@ -881,9 +969,7 @@ export async function login(props?: LoginProps): Promise<boolean> {
             res.end(() => {
               finish(true);
             });
-            console.log(
-              `Successfully configured. You can find your configuration file at: ${os.homedir()}/.wrangler/config/default.toml`
-            );
+            console.log(`Successfully logged in.`);
 
             return;
           }
@@ -894,24 +980,30 @@ export async function login(props?: LoginProps): Promise<boolean> {
     server.listen(8976);
   });
 
+  await openInBrowser(urlToOpen);
+
   return Promise.race([timerPromise, loginPromise]);
 }
 
 /**
  * Checks to see if the access token has expired.
  */
-export function isAccessTokenExpired(): boolean {
-  throwIfNotInitialised();
+function isAccessTokenExpired(): boolean {
   const { accessToken } = LocalState;
   return Boolean(accessToken && new Date() >= new Date(accessToken.expiry));
 }
 
-export async function refreshToken(): Promise<boolean> {
-  throwIfNotInitialised();
+async function refreshToken(): Promise<boolean> {
   // refresh
   try {
-    const refreshed = await exchangeRefreshTokenForAccessToken();
-    await writeToConfigFile(refreshed);
+    const {
+      token: { value: oauth_token, expiry: expiration_time } = {
+        value: "",
+        expiry: "",
+      },
+      refreshToken: { value: refresh_token } = {},
+    } = await exchangeRefreshTokenForAccessToken();
+    writeAuthConfigFile({ oauth_token, expiration_time, refresh_token });
     return true;
   } catch (err) {
     console.error(err);
@@ -920,16 +1012,33 @@ export async function refreshToken(): Promise<boolean> {
 }
 
 export async function logout(): Promise<void> {
-  throwIfNotInitialised();
-  const { refreshToken } = LocalState;
-  if (!refreshToken) {
-    console.log("Not logged in, exiting...");
-    return;
+  if (!LocalState.accessToken) {
+    if (!LocalState.refreshToken) {
+      console.log("Not logged in, exiting...");
+      return;
+    }
+
+    const body =
+      `client_id=${encodeURIComponent(CLIENT_ID)}&` +
+      `token_type_hint=refresh_token&` +
+      `token=${encodeURIComponent(LocalState.refreshToken?.value || "")}`;
+
+    const response = await fetch(REVOKE_URL, {
+      method: "POST",
+      body,
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+    });
+    await response.text(); // blank text? would be nice if it was something meaningful
+    console.log(
+      "💁  Wrangler is configured with an OAuth token. The token has been successfully revoked"
+    );
   }
   const body =
     `client_id=${encodeURIComponent(CLIENT_ID)}&` +
     `token_type_hint=refresh_token&` +
-    `token=${encodeURIComponent(refreshToken?.value || "")}`;
+    `token=${encodeURIComponent(LocalState.refreshToken?.value || "")}`;
 
   const response = await fetch(REVOKE_URL, {
     method: "POST",
@@ -939,38 +1048,34 @@ export async function logout(): Promise<void> {
     },
   });
   await response.text(); // blank text? would be nice if it was something meaningful
-  console.log(
-    "💁  Wrangler is configured with an OAuth token. The token has been successfully revoked"
-  );
-  // delete the file
-  await rm(path.join(os.homedir(), ".wrangler/config/default.toml"));
-  console.log(
-    `Removing ${os.homedir()}/.wrangler/config/default.toml.. success!`
-  );
+  rmSync(path.join(os.homedir(), USER_AUTH_CONFIG_FILE));
+  console.log(`Successfully logged out.`);
 }
 
-export function listScopes(): void {
-  throwIfNotInitialised();
-  console.log("💁 Available scopes:");
-  const data = Scopes.map((scope, index) => ({
+export function listScopes(message = "💁 Available scopes:"): void {
+  console.log(message);
+  const data = ScopeKeys.map((scope: Scope) => ({
     Scope: scope,
-    Description: ScopeDescriptions[index],
+    Description: Scopes[scope],
   }));
   render(<Table data={data} />);
   // TODO: maybe a good idea to show usage here
 }
 
-export async function getAccountId() {
+export async function getAccountId(
+  isInteractive = true
+): Promise<string | undefined> {
   const apiToken = getAPIToken();
   if (!apiToken) return;
 
-  if (process.env.CF_ACCOUNT_ID) {
-    return process.env.CF_ACCOUNT_ID;
+  const accountIdFromEnv = getCloudflareAccountIdFromEnv();
+  if (accountIdFromEnv) {
+    return accountIdFromEnv;
   }
 
   let response: Response;
   try {
-    response = await fetch(`${CF_API_BASE_URL}/memberships`, {
+    response = await fetch(`${getCloudflareApiBaseUrl()}/memberships`, {
       method: "GET",
       headers: {
         Authorization: "Bearer " + apiToken,
@@ -978,19 +1083,19 @@ export async function getAccountId() {
     });
   } catch (err) {
     // probably offline
+    return;
   }
-  if (!response) return;
-  let accountId: string;
-  // @ts-expect-error need to type this response
-  const responseJSON: {
+
+  let accountId: string | undefined;
+  const responseJSON = (await response.json()) as {
     success: boolean;
     result: { id: string; account: { id: string; name: string } }[];
-  } = await response.json();
+  };
 
   if (responseJSON.success === true) {
     if (responseJSON.result.length === 1) {
       accountId = responseJSON.result[0].account.id;
-    } else {
+    } else if (isInteractive) {
       accountId = await new Promise((resolve) => {
         const accounts = responseJSON.result.map((x) => x.account);
         const { unmount } = render(
@@ -1003,6 +1108,15 @@ export async function getAccountId() {
           />
         );
       });
+    } else {
+      throw new Error(
+        "More than one account available but unable to select one in non-interactive mode.\n" +
+          `Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.\n` +
+          `Available accounts are ("<name>" - "<id>"):\n` +
+          responseJSON.result
+            .map((x) => `  "${x.account.name}" - "${x.account.id}")`)
+            .join("\n")
+      );
     }
   }
   return accountId;
@@ -1014,16 +1128,39 @@ type ChooseAccountItem = {
 };
 export function ChooseAccount(props: {
   accounts: ChooseAccountItem[];
-  onSelect: (item) => void;
+  onSelect: (item: SelectInputItem<ChooseAccountItem>) => void;
 }) {
   return (
-    <SelectInput
-      items={props.accounts.map((item) => ({
-        key: item.id,
-        label: item.name,
-        value: item,
-      }))}
-      onSelect={props.onSelect}
-    />
+    <>
+      <Text bold>Select an account from below:</Text>
+      <SelectInput
+        items={props.accounts.map((item) => ({
+          key: item.id,
+          label: item.name,
+          value: item,
+        }))}
+        onSelect={props.onSelect}
+      />
+    </>
   );
 }
+
+/**
+ * Ensure that a user is logged in, and a valid account_id is available.
+ */
+export async function requireAuth(
+  config: Config,
+  isInteractive = true
+): Promise<string> {
+  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;
+}