wrangler 0.0.0-e2a26a0 → 0.0.0-e3cab74

package/src/tail/index.ts

@@ -0,0 +1,299 @@
+import WebSocket from "ws";
+import { version as packageVersion } from "../../package.json";
+import { fetchResult } from "../cfetch";
+import type { TailFilterMessage, Outcome } from "./filters";
+export type { TailCLIFilters } from "./filters";
+export { translateCLICommandToFilterMessage } from "./filters";
+export { jsonPrintLogs, prettyPrintLogs } from "./printing";
+import type { Request } from "undici";
+
+/**
+ * When creating a Tail, the response from the API contains
+ * - an ID used for identifying the tail
+ * - a URL to a WebSocket connection available for the tail to connect to
+ * - an expiration date when the tail is no longer guaranteed to be valid
+ */
+type TailCreationApiResponse = {
+  id: string;
+  url: string;
+  expires_at: Date;
+};
+
+/**
+ * Generate a URL that, when `cfetch`ed, creates a tail.
+ *
+ * https://api.cloudflare.com/#worker-tail-logs-start-tail
+ *
+ * @param accountId the account ID associated with the worker to tail
+ * @param workerName the name of the worker to tail
+ * @returns a `cfetch`-ready URL for creating a new tail
+ */
+function makeCreateTailUrl(
+  accountId: string,
+  workerName: string,
+  env: string | undefined
+): string {
+  return env
+    ? `/accounts/${accountId}/workers/services/${workerName}/environments/${env}/tails`
+    : `/accounts/${accountId}/workers/scripts/${workerName}/tails`;
+}
+
+/**
+ * Generate a URL that, when `cfetch`ed, deletes a tail
+ *
+ * https://api.cloudflare.com/#worker-tail-logs-delete-tail
+ *
+ * @param accountId the account ID associated with the worker we're tailing
+ * @param workerName the name of the worker we're tailing
+ * @param tailId the ID of the tail we want to delete
+ * @returns a `cfetch`-ready URL for deleting a tail
+ */
+function makeDeleteTailUrl(
+  accountId: string,
+  workerName: string,
+  tailId: string,
+  env: string | undefined
+): string {
+  return env
+    ? `/accounts/${accountId}/workers/services/${workerName}/environments/${env}/tails/${tailId}`
+    : `/accounts/${accountId}/workers/scripts/${workerName}/tails/${tailId}`;
+}
+
+/**
+ * Create and connect to a tail.
+ *
+ * Under the hood, this function
+ * - Registers a new Tail with the API
+ * - Connects to the tail worker
+ * - Sends any filters over the connection
+ *
+ * @param accountId the account ID associated with the worker to tail
+ * @param workerName the name of the worker to tail
+ * @param message a `TailFilterMessage` to send up to the tail worker
+ * @returns a websocket connection, an expiration, and a function to call to delete the tail
+ */
+export async function createTail(
+  accountId: string,
+  workerName: string,
+  message: TailFilterMessage,
+  env: string | undefined
+): Promise<{
+  tail: WebSocket;
+  expiration: Date;
+  deleteTail: () => Promise<void>;
+}> {
+  // create the tail
+  const createTailUrl = makeCreateTailUrl(accountId, workerName, env);
+  const {
+    id: tailId,
+    url: websocketUrl,
+    expires_at: expiration,
+  } = await fetchResult<TailCreationApiResponse>(createTailUrl, {
+    method: "POST",
+  });
+
+  // delete the tail (not yet!)
+  const deleteUrl = makeDeleteTailUrl(accountId, workerName, tailId, env);
+  async function deleteTail() {
+    await fetchResult(deleteUrl, { method: "DELETE" });
+  }
+
+  // connect to the tail
+  const tail = new WebSocket(websocketUrl, "trace-v1", {
+    headers: {
+      "Sec-WebSocket-Protocol": "trace-v1", // needs to be `trace-v1` to be accepted
+      "User-Agent": `wrangler-js/${packageVersion}`,
+    },
+  });
+
+  // send filters when we open up
+  tail.on("open", function () {
+    tail.send(
+      JSON.stringify(message),
+      { binary: false, compress: false, mask: false, fin: true },
+      (err) => {
+        if (err) {
+          throw err;
+        }
+      }
+    );
+  });
+
+  return { tail, expiration, deleteTail };
+}
+
+/**
+ * Everything captured by the trace worker and sent to us via
+ * `wrangler tail` is structured JSON that deserializes to this type.
+ */
+export type TailEventMessage = {
+  /**
+   * Whether the execution of this worker succeeded or failed
+   */
+  outcome: Outcome;
+
+  /**
+   * The name of the script we're tailing
+   */
+  scriptName?: string;
+
+  /**
+   * Any exceptions raised by the worker
+   */
+  exceptions: {
+    /**
+     * The name of the exception.
+     */
+    name: string;
+
+    /**
+     * The error message
+     */
+    message: unknown;
+
+    /**
+     * When the exception was raised/thrown
+     */
+    timestamp: number;
+  }[];
+
+  /**
+   * Any logs sent out by the worker
+   */
+  logs: {
+    message: unknown;
+    level: string; // TODO: make this a union of possible values
+    timestamp: number;
+  }[];
+
+  /**
+   * When the event was triggered
+   */
+  eventTimestamp: number;
+
+  /**
+   * The event that triggered the worker. In the case of an HTTP request,
+   * this will be a RequestEvent. If it's a cron trigger, it'll be a
+   * ScheduledEvent.
+   *
+   * Until workers-types exposes individual types for export, we'll have
+   * to just re-define these types ourselves.
+   */
+  event: RequestEvent | ScheduledEvent;
+};
+
+/**
+ * A request that triggered worker execution
+ */
+
+export type RequestEvent = {
+  request: Pick<Request, "url" | "method" | "headers"> & {
+    /**
+     * Cloudflare-specific properties
+     * https://developers.cloudflare.com/workers/runtime-apis/request#incomingrequestcfproperties
+     */
+    cf: {
+      /**
+       * How long (in ms) it took for the client's TCP connection to make a
+       * round trip to the worker and back. For all my gamers out there,
+       * this is the request's ping
+       */
+      clientTcpRtt?: number;
+
+      /**
+       * Longitude and Latitude of where the request originated from
+       */
+      longitude?: string;
+      latitude?: string;
+
+      /**
+       * What cipher was used to establish the TLS connection
+       */
+      tlsCipher: string;
+
+      /**
+       * Which continent the request came from.
+       */
+      continent?: "NA";
+
+      /**
+       * ASN of the incoming request
+       */
+      asn: number;
+
+      /**
+       * The country the incoming request is coming from
+       */
+      country?: string;
+
+      /**
+       * The TLS version the connection used
+       */
+      tlsVersion: string;
+
+      /**
+       * The colo that processed the request (i.e. the airport code
+       * of the closest city to the server that spun up the worker)
+       */
+      colo: string;
+
+      /**
+       * The timezone where the request came from
+       */
+      timezone?: string;
+
+      /**
+       * The city where the request came from
+       */
+      city?: string;
+
+      /**
+       * The browser-requested prioritization information in the request object
+       */
+      requestPriority?: string;
+
+      /**
+       * Which version of HTTP the request came over e.g. "HTTP/2"
+       */
+      httpProtocol: string;
+
+      /**
+       * The region where the request originated from
+       */
+      region?: string;
+      regionCode?: string;
+
+      /**
+       * The organization which owns the ASN of the incoming request, for example, Google Cloud.
+       */
+      asOrganization: string;
+
+      /**
+       * Metro code (DMA) of the incoming request, for example, "635".
+       */
+      metroCode?: string;
+
+      /**
+       * Postal code of the incoming request, for example, "78701".
+       */
+      postalCode?: string;
+    };
+  };
+};
+
+/**
+ * An event that was triggered at a certain time
+ */
+export type ScheduledEvent = {
+  /**
+   * The cron pattern that matched when this event fired
+   */
+  cron: string;
+
+  /**
+   * The time this worker was scheduled to run.
+   * For some reason, this doesn't...work correctly when we
+   * do it directly as a Date. So parse it later on your own.
+   */
+  scheduledTime: number;
+};

package/src/tail/printing.ts

@@ -0,0 +1,62 @@
+import type { RequestEvent, ScheduledEvent, TailEventMessage } from ".";
+import type { Outcome } from "./filters";
+import type WebSocket from "ws";
+
+export function prettyPrintLogs(data: WebSocket.RawData): void {
+  const eventMessage: TailEventMessage = JSON.parse(data.toString());
+
+  if (isScheduledEvent(eventMessage.event)) {
+    const cronPattern = eventMessage.event.cron;
+    const datetime = new Date(
+      eventMessage.event.scheduledTime
+    ).toLocaleString();
+    const outcome = prettifyOutcome(eventMessage.outcome);
+
+    console.log(`"${cronPattern}" @ ${datetime} - ${outcome}`);
+  } else {
+    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}`);
+  }
+
+  if (eventMessage.logs.length > 0) {
+    eventMessage.logs.forEach(({ level, message }) => {
+      console.log(`  (${level}) ${message}`);
+    });
+  }
+
+  if (eventMessage.exceptions.length > 0) {
+    eventMessage.exceptions.forEach(({ name, message }) => {
+      console.error(`  ${name}: ${message}`);
+    });
+  }
+}
+
+export function jsonPrintLogs(data: WebSocket.RawData): void {
+  console.log(JSON.stringify(JSON.parse(data.toString()), null, 2));
+}
+
+function isScheduledEvent(
+  event: RequestEvent | ScheduledEvent
+): event is ScheduledEvent {
+  return "cron" in event;
+}
+
+function prettifyOutcome(outcome: Outcome): string {
+  switch (outcome) {
+    case "ok":
+      return "Ok";
+    case "canceled":
+      return "Canceled";
+    case "exceededCpu":
+      return "Exceeded CPU Limit";
+    case "exception":
+      return "Exception Thrown";
+    case "unknown":
+    default:
+      return "Unknown";
+  }
+}

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
@@ -211,20 +211,37 @@ import { readFile, writeFile, rm, mkdir } from "node:fs/promises";
 import http from "node:http";
 import os from "node:os";
 import path from "node:path";
-import process from "node:process";
 import url from "node:url";
 import { TextEncoder } from "node:util";
 import TOML from "@iarna/toml";
 import { render, Text } from "ink";
 import SelectInput from "ink-select-input";
 import Table from "ink-table";
-import open from "open";
 import React from "react";
 import { fetch } from "undici";
-import { CF_API_BASE_URL } from "./cfetch";
+import { getCloudflareApiBaseUrl } from "./cfetch";
+import { getEnvironmentVariableFactory } from "./environment-variables";
+import openInBrowser from "./open-in-browser";
+import type { Item as SelectInputItem } from "ink-select-input/build/SelectInput";
 import type { ParsedUrlQuery } from "node:querystring";
 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.
  */
@@ -276,14 +293,14 @@ const Scopes = {
  *
  * "offline_access" is automatically included.
  */
-type Scope = keyof typeof Scopes | "offline_access";
+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) => Scopes[scope]);
+  return scopes.every((scope) => scope in Scopes);
 }
 
 const CLIENT_ID = "54d11594-84e4-41aa-b438-e81b8fa78ee7";
@@ -301,10 +318,11 @@ let initialised = false;
 export async function initialise(): Promise<void> {
   // get refreshToken/accessToken from fs if exists
   try {
-    // if CF_API_TOKEN available, use that
-    if (process.env.CF_API_TOKEN) {
+    // if the environment variable is available, use that
+    const apiTokenFromEnv = getCloudflareAPITokenFromEnv();
+    if (apiTokenFromEnv) {
       LocalState.accessToken = {
-        value: process.env.CF_API_TOKEN,
+        value: apiTokenFromEnv,
         expiry: "3021-12-31T23:59:59+00:00",
       };
       initialised = true;
@@ -344,9 +362,6 @@ function throwIfNotInitialised() {
 }
 
 export function getAPIToken(): string | undefined {
-  if (process.env.CF_API_TOKEN) {
-    return process.env.CF_API_TOKEN;
-  }
   throwIfNotInitialised();
   return LocalState.accessToken?.value;
 }
@@ -561,6 +576,7 @@ 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(" "))}&` +
     `state=${stateQueryParam}&` +
     `code_challenge=${encodeURIComponent(codeChallenge)}&` +
@@ -568,6 +584,17 @@ export async function getAuthURL(scopes = ScopeKeys): Promise<string> {
   );
 }
 
+type TokenResponse =
+  | {
+      access_token: string;
+      expires_in: number;
+      refresh_token: string;
+      scope: string;
+    }
+  | {
+      error: string;
+    };
+
 /**
  * Refresh an access token from the remote service.
  */
@@ -592,13 +619,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 = {
@@ -626,20 +652,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;
+      }
     }
   }
 }
@@ -680,13 +710,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;
 
@@ -804,18 +832,18 @@ export async function loginOrRefreshIfRequired(): Promise<boolean> {
 
 export async function login(props?: LoginProps): Promise<boolean> {
   const urlToOpen = await getAuthURL(props?.scopes);
-  await open(urlToOpen);
-  // TODO: log url only if on system where it's unreliable/unavailable
-  // console.log(`💁 Opened ${urlToOpen}`);
-  let server;
-  let loginTimeoutHandle;
+  await openInBrowser(urlToOpen);
+  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) => {
@@ -846,8 +874,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 {
@@ -939,7 +968,7 @@ export async function logout(): Promise<void> {
 export function listScopes(): void {
   throwIfNotInitialised();
   console.log("💁 Available scopes:");
-  const data = ScopeKeys.map((scope) => ({
+  const data = ScopeKeys.map((scope: Scope) => ({
     Scope: scope,
     Description: Scopes[scope],
   }));
@@ -951,13 +980,14 @@ export async function getAccountId() {
   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,
@@ -1001,7 +1031,7 @@ type ChooseAccountItem = {
 };
 export function ChooseAccount(props: {
   accounts: ChooseAccountItem[];
-  onSelect: (item) => void;
+  onSelect: (item: SelectInputItem<ChooseAccountItem>) => void;
 }) {
   return (
     <>

package/templates/new-worker.js

@@ -3,7 +3,7 @@
  *
  * - Run `npx wrangler dev src/index.js` in your terminal to start a development server
  * - Open a browser tab at http://localhost:8787/ to see your worker in action
- * - Run `npx wrangler publish src/index.js --name my-worker` to deploy your worker
+ * - Run `npx wrangler publish src/index.js --name my-worker` to publish your worker
  *
  * Learn more at https://developers.cloudflare.com/workers/
  */

package/templates/new-worker.ts

@@ -3,7 +3,7 @@
  *
  * - Run `wrangler dev src/index.ts` in your terminal to start a development server
  * - Open a browser tab at http://localhost:8787/ to see your worker in action
- * - Run `wrangler publish src/index.ts --name my-worker` to deploy your worker
+ * - Run `wrangler publish src/index.ts --name my-worker` to publish your worker
  *
  * Learn more at https://developers.cloudflare.com/workers/
  */