wrangler 0.0.0-e2a26a0 → 0.0.0-e3a458e

package/src/r2.ts

@@ -0,0 +1,50 @@
+import { fetchResult } from "./cfetch";
+
+/**
+ * Information about a bucket, returned from `listR2Buckets()`.
+ */
+export interface R2BucketInfo {
+  name: string;
+  creation_date: string;
+}
+
+/**
+ * Fetch a list of all the buckets under the given `accountId`.
+ */
+export async function listR2Buckets(
+  accountId: string
+): Promise<R2BucketInfo[]> {
+  const results = await fetchResult<{
+    buckets: R2BucketInfo[];
+  }>(`/accounts/${accountId}/r2/buckets`);
+  return results.buckets;
+}
+
+/**
+ * Create a bucket with the given `bucketName` within the account given by `accountId`.
+ *
+ * A 400 is returned if the account already owns a bucket with this name.
+ * A bucket must be explicitly deleted to be replaced.
+ */
+export async function createR2Bucket(
+  accountId: string,
+  bucketName: string
+): Promise<void> {
+  return await fetchResult<void>(
+    `/accounts/${accountId}/r2/buckets/${bucketName}`,
+    { method: "PUT" }
+  );
+}
+
+/**
+ * Delete a bucket with the given name
+ */
+export async function deleteR2Bucket(
+  accountId: string,
+  bucketName: string
+): Promise<void> {
+  return await fetchResult<void>(
+    `/accounts/${accountId}/r2/buckets/${bucketName}`,
+    { method: "DELETE" }
+  );
+}

package/src/reporting.ts

@@ -0,0 +1,131 @@
+import * as fs from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import TOML from "@iarna/toml";
+import { RewriteFrames } from "@sentry/integrations";
+import {
+  captureException,
+  getCurrentHub,
+  startTransaction,
+  init,
+  Integrations,
+  setContext,
+} from "@sentry/node";
+import { execaSync } from "execa";
+import prompts from "prompts";
+import * as pkj from "../package.json";
+
+export function initReporting() {
+  init({
+    release: `${pkj.name}@${pkj.version}`,
+    initialScope: {
+      tags: { [pkj.name]: pkj.version },
+    },
+    beforeBreadcrumb: (_breadcrumb, _hint) => {
+      // eventually, we might want to actually start dropping our own breadcrumbs.
+      // until then, we want to just ignore all of them, since sentry will
+      // automatically include breadcrumbs for things like console output,
+      // which can include unsanitized data that the user logs
+      // from their worker during development
+      return null;
+    },
+    dsn: "https://5089b76bf8a64a9c949bf5c2b5e8003c@o51786.ingest.sentry.io/6190959",
+    tracesSampleRate: 1.0,
+    integrations: [
+      new RewriteFrames({
+        root: "",
+        prefix: "/",
+      }),
+      new Integrations.Http({ tracing: true }),
+    ],
+  });
+
+  setContext("System Information", {
+    OS: process.platform,
+    node: process.version,
+    npm: execaSync("npm", ["--version"]).stdout,
+    wrangler: pkj.version,
+  });
+}
+
+async function appendReportingDecision(userInput: "true" | "false") {
+  const homePath = path.join(os.homedir(), ".wrangler/config/");
+  const reportingConfigLocation = path.join(homePath, "reporting.toml");
+  try {
+    fs.mkdirSync(homePath, { recursive: true });
+    await writeFile(
+      reportingConfigLocation,
+      `error_tracking_opt = ${userInput} # Sentry \nerror_tracking_opt_date = ${new Date().toISOString()} # Sentry Date Decision \n`,
+      "utf-8"
+    );
+  } catch (err) {
+    console.warn(
+      `Unable to create wrangler's error reporting configuration file at ${reportingConfigLocation}: `,
+      err
+    );
+  }
+}
+
+function exceptionTransaction(error: Error, origin = "") {
+  const transaction = startTransaction({
+    op: origin,
+    name: error.name,
+  });
+  captureException(error);
+  transaction.finish();
+}
+
+export async function reportError(err: Error, origin = "") {
+  if (!process.stdout.isTTY) return await appendReportingDecision("false");
+
+  const errorTrackingOpt = await reportingPermission();
+
+  if (errorTrackingOpt === undefined) {
+    const userInput = await prompts.prompt({
+      type: "select",
+      name: "sentryDecision",
+      message: "Would you like to submit a report when an error occurs?",
+      choices: [
+        { title: "Always", value: true },
+        { title: "Only this time", value: "once" },
+        { title: "No", value: false },
+      ],
+      initial: 2,
+    });
+
+    if (userInput.sentryDecision === "once") {
+      exceptionTransaction(err, origin);
+      return;
+    }
+
+    userInput.sentryDecision
+      ? await appendReportingDecision("true")
+      : await appendReportingDecision("false");
+  }
+
+  if (!errorTrackingOpt) {
+    const sentryClient = getCurrentHub().getClient();
+    if (sentryClient !== undefined) sentryClient.getOptions().enabled = false;
+  }
+
+  exceptionTransaction(err, origin);
+}
+
+async function reportingPermission() {
+  if (
+    !fs.existsSync(path.join(os.homedir(), ".wrangler/config/reporting.toml"))
+  )
+    return undefined;
+
+  const reportingTOML = TOML.parse(
+    await readFile(path.join(os.homedir(), ".wrangler/config/reporting.toml"), {
+      encoding: "utf-8",
+    })
+  );
+  const { error_tracking_opt } = reportingTOML as {
+    error_tracking_opt: string | undefined;
+  };
+
+  return error_tracking_opt;
+}

package/src/selfsigned.d.ts

@@ -0,0 +1,29 @@
+declare module "selfsigned" {
+  import type { pki } from "node-forge";
+
+  export type Attributes = pki.CertificateField[];
+
+  export interface Options {
+    days?: number;
+    keySize?: number;
+    extensions?: unknown[];
+    algorithm?: string;
+    pkcs7?: boolean;
+    clientCertificate?: boolean;
+    clientCertificateCN?: string;
+  }
+
+  export interface Certificate {
+    private: string;
+    public: string;
+    cert: string;
+    fingerprint: string;
+  }
+
+  export function generate(attrs?: Attributes, options?: Options): Certificate;
+  export function generate(
+    attrs: Attributes,
+    options: Options,
+    callback: (err: Error, certificate: Certificate) => void
+  ): void;
+}

package/src/sites.tsx

@@ -1,33 +1,34 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import * as path from "node:path";
 import ignore from "ignore";
-import { XXHash64 } from "xxhash-addon";
+import xxhash from "xxhash-wasm";
 import {
   createNamespace,
+  getKeyValue,
   listNamespaceKeys,
   listNamespaces,
   putBulkKeyValue,
 } from "./kv";
 import type { Config } from "./config";
+import type { KeyValue, NamespaceKeyInfo } from "./kv";
+import type { XXHashAPI } from "xxhash-wasm";
 
 /** Paths to always ignore. */
-const ALWAYS_IGNORE = ["node_modules"];
-const HIDDEN_FILES_TO_INCLUDE = [
+const ALWAYS_IGNORE = new Set(["node_modules"]);
+const HIDDEN_FILES_TO_INCLUDE = new Set([
   ".well-known", // See https://datatracker.ietf.org/doc/html/rfc8615
-];
+]);
+const FIVE_MINUTES = 60 * 5; // expressed in seconds, since that's what the api expects
 
 async function* getFilesInFolder(dirPath: string): AsyncIterable<string> {
   const files = await readdir(dirPath, { withFileTypes: true });
   for (const file of files) {
     // Skip files that we never want to process.
-    if (ALWAYS_IGNORE.some((p) => file.name === p)) {
+    if (ALWAYS_IGNORE.has(file.name)) {
       continue;
     }
     // Skip hidden files (starting with .) except for some special ones
-    if (
-      file.name.startsWith(".") &&
-      !HIDDEN_FILES_TO_INCLUDE.some((p) => file.name === p)
-    ) {
+    if (file.name.startsWith(".") && !HIDDEN_FILES_TO_INCLUDE.has(file.name)) {
       continue;
     }
     // TODO: follow symlinks??
@@ -46,11 +47,8 @@ async function* getFilesInFolder(dirPath: string): AsyncIterable<string> {
  * the most important thing here is to detect changes of a single file to invalidate the cache and
  * it's impossible to serve two different files with the same name
  */
-function hashFileContent(content: string): string {
-  const hasher = new XXHash64();
-  hasher.update(Buffer.from(content));
-  const hash = hasher.digest();
-  return hash.toString("hex").substring(0, 10);
+function hashFileContent(hasher: XXHashAPI, content: string): string {
+  return hasher.h64ToString(content).substring(0, 10);
 }
 
 /**
@@ -59,11 +57,15 @@ function hashFileContent(content: string): string {
  * The key will change if the file path or content of the asset changes.
  * The algorithm used here matches that of Wrangler 1.
  */
-function hashAsset(filePath: string, content: string): string {
+function hashAsset(
+  hasher: XXHashAPI,
+  filePath: string,
+  content: string
+): string {
   const extName = path.extname(filePath) || "";
   const baseName = path.basename(filePath, extName);
   const directory = path.dirname(filePath);
-  const hash = hashFileContent(content);
+  const hash = hashFileContent(hasher, content);
   return urlSafe(path.join(directory, `${baseName}.${hash}${extName}`));
 }
 
@@ -97,7 +99,6 @@ async function createKVNamespaceIfNotAlreadyExisting(
  * @param scriptName the name of the worker whose assets we are uploading.
  * @param siteAssets an objects describing what assets to upload, or undefined if there are no assets to upload.
  * @param preview if true then upload to a "preview" KV namespace.
- * @param _env (not implemented).
  * @returns a promise for an object mapping the relative paths of the assets to the key of that
  * asset in the KV namespace.
  */
@@ -105,8 +106,7 @@ export async function syncAssets(
   accountId: string,
   scriptName: string,
   siteAssets: AssetPaths | undefined,
-  preview: boolean,
-  env: string | undefined
+  preview: boolean
 ): Promise<{
   manifest: { [filePath: string]: string } | undefined;
   namespace: string | undefined;
@@ -115,7 +115,7 @@ export async function syncAssets(
     return { manifest: undefined, namespace: undefined };
   }
 
-  const title = `__${scriptName}${env ? `-${env}` : ""}-workers_sites_assets${
+  const title = `__${scriptName}-workers_sites_assets${
     preview ? "_preview" : ""
   }`;
   const { id: namespace } = await createKVNamespaceIfNotAlreadyExisting(
@@ -125,18 +125,18 @@ export async function syncAssets(
 
   // 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 keyMap = result.reduce<Record<string, NamespaceKeyInfo>>(
+    (km, key) => Object.assign(km, { [key.name]: key }),
+    {}
+  );
 
-  const manifest = {};
-  const upload: {
-    key: string;
-    value: string;
-    base64: boolean;
-  }[] = [];
+  const manifest: Record<string, string> = {};
+  const toUpload: KeyValue[] = [];
 
   const include = createPatternMatcher(siteAssets.includePatterns, false);
   const exclude = createPatternMatcher(siteAssets.excludePatterns, true);
-  // TODO: this can be more efficient by parallelising
+  const hasher = await xxhash();
+
   for await (const file of getFilesInFolder(siteAssets.baseDirectory)) {
     if (!include(file)) {
       continue;
@@ -149,13 +149,13 @@ export async function syncAssets(
     console.log(`reading ${file}...`);
     const content = await readFile(file, "base64");
 
-    const assetKey = hashAsset(file, content);
+    const assetKey = hashAsset(hasher, file, content);
     validateAssetKey(assetKey);
 
     // now put each of the files into kv
-    if (!keys.has(assetKey)) {
+    if (!(assetKey in keyMap) || keyMap[assetKey].expiration) {
       console.log(`uploading as ${assetKey}...`);
-      upload.push({
+      toUpload.push({
         key: assetKey,
         value: content,
         base64: true,
@@ -163,9 +163,43 @@ export async function syncAssets(
     } else {
       console.log(`skipping - already uploaded`);
     }
+    // remove the key from the set so we know we've seen it
+    delete keyMap[assetKey];
     manifest[path.relative(siteAssets.baseDirectory, file)] = assetKey;
   }
-  await putBulkKeyValue(accountId, namespace, JSON.stringify(upload));
+
+  // `keyMap` now contains the assets that we need to expire
+
+  let toExpire: KeyValue[] = [];
+  for (const asset of Object.values(keyMap)) {
+    if (!asset.expiration) {
+      console.log(`expiring unused ${asset.name}...`);
+      toExpire.push({
+        key: asset.name,
+        value: "", // we'll fill all the values in one go
+        // we use expiration_ttl, since we can't trust the time
+        // that a deploy source might provide (eg - https://github.com/cloudflare/wrangler/issues/2224)
+        expiration_ttl: FIVE_MINUTES,
+        base64: true,
+      });
+    }
+  }
+
+  // TODO: batch these in groups if it causes problems
+  toExpire = await Promise.all(
+    toExpire.map(async (asset) => ({
+      ...asset,
+      // it would be great if we didn't have to do this fetch at all
+      value: await getKeyValue(accountId, namespace, asset.key),
+    }))
+  );
+
+  await putBulkKeyValue(
+    accountId,
+    namespace,
+    toUpload.concat(toExpire),
+    () => {}
+  );
   return { manifest, namespace };
 }
 
@@ -222,7 +256,6 @@ export interface AssetPaths {
  * Uses the args (passed from the command line) if available,
  * falling back to those defined in the config.
  *
- * // TODO: Support for environments
  */
 export function getAssetPaths(
   config: Config,

package/src/tail/filters.ts

@@ -0,0 +1,279 @@
+/**
+ * When tailing logs from a worker, oftentimes you don't want to see _every
+ * single event_. That's where filters come in. We can send a set of filters
+ * to the tail worker, and it will pre-filter any logs for us so that we
+ * only recieve the ones we care about.
+ */
+
+/**
+ * These are the filters we accept in the CLI. They
+ * were copied directly from wrangler 1 in order to
+ * maintain compatability, so they aren't actually the exact
+ * filters we need to send up to the tail worker. They generally map 1:1,
+ * but often require some transformation or
+ * renaming to match what it expects.
+ *
+ * For a full description of each filter, either check the
+ * CLI description or see the documentation for `ApiFilter`.
+ */
+export type TailCLIFilters = {
+  status?: ("ok" | "error" | "canceled")[];
+  header?: string;
+  method?: string[];
+  search?: string;
+  samplingRate?: number;
+  clientIp?: string[];
+};
+
+/**
+ * These are the filters we send to the tail worker. We
+ * actually send a list of filters (an array of objects),
+ * so rather than having a single TailAPIFilters type,
+ * each kind of filter gets its own type and we define
+ * TailAPIFilter to be the union of those types.
+ */
+export type TailAPIFilter =
+  | SamplingRateFilter
+  | OutcomeFilter
+  | MethodFilter
+  | HeaderFilter
+  | ClientIPFilter
+  | QueryFilter;
+
+/**
+ * Filters logs based on a given sampling rate.
+ * For example, a `sampling_rate` of 0.25 will let one-quarter of the
+ * logs through.
+ */
+type SamplingRateFilter = {
+  sampling_rate: number;
+};
+
+/**
+ * Filters logs based on the outcome of the worker's event handler.
+ */
+type OutcomeFilter = {
+  outcome: Outcome[];
+};
+
+/**
+ * There are five possible outcomes we can get, three of which
+ * (exception, exceededCpu, and unknown) are considered errors
+ */
+export type Outcome =
+  | "ok"
+  | "canceled"
+  | "exception"
+  | "exceededCpu"
+  | "unknown";
+
+/**
+ * Filters logs based on the HTTP method used for the request
+ * that triggered the worker.
+ */
+type MethodFilter = {
+  method: string[];
+};
+
+/**
+ * Filters logs based on an HTTP header on the request that
+ * triggered the worker.
+ */
+type HeaderFilter = {
+  header: {
+    /**
+     * Filters on the header "key", e.g. "X-CLOUDFLARE-HEADER"
+     * or "X-CUSTOM-HEADER"
+     */
+    key: string;
+
+    /**
+     * Filters on the header "value", e.g. if this is set to
+     * "filter-for-me" and the "key" is "X-SHOULD-LOG", only
+     * events triggered by requests with the header
+     * "X-SHOULD-LOG:filter-for-me" will be logged.
+     */
+    query?: string;
+  };
+};
+
+/**
+ * Filters on the IP address the request came from that triggered
+ * the worker. A value of "self" will be replaced with the IP
+ * address that is running `wrangler tail`
+ */
+type ClientIPFilter = {
+  client_ip: string[];
+};
+
+/**
+ * Filters logs by a query string. This means only logs that
+ * contain the given string will be sent to wrangler, and any
+ * that don't will be discarded by the tail worker.
+ */
+type QueryFilter = {
+  query: string;
+};
+
+/**
+ * The full message we send to the tail worker includes our
+ * filters and a debug flag.
+ */
+export type TailFilterMessage = {
+  filters: TailAPIFilter[];
+  debug: boolean;
+};
+
+/**
+ * Translate the flags passed in via a CLI invokation of wrangler
+ * into a message that we can send to the tail worker.
+ *
+ * @param cliFilters An object containing all the filters passed in from the CLI
+ * @param debug Whether or not we should be in debug mode
+ * @returns A filter message ready to be sent to the tail worker
+ */
+export function translateCLICommandToFilterMessage(
+  cliFilters: TailCLIFilters,
+  debug: boolean
+): TailFilterMessage {
+  const apiFilters: TailAPIFilter[] = [];
+
+  if (cliFilters.samplingRate) {
+    apiFilters.push(parseSamplingRate(cliFilters.samplingRate));
+  }
+
+  if (cliFilters.status) {
+    apiFilters.push(parseOutcome(cliFilters.status));
+  }
+
+  if (cliFilters.method) {
+    apiFilters.push(parseMethod(cliFilters.method));
+  }
+
+  if (cliFilters.header) {
+    apiFilters.push(parseHeader(cliFilters.header));
+  }
+
+  if (cliFilters.clientIp) {
+    apiFilters.push(parseIP(cliFilters.clientIp));
+  }
+
+  if (cliFilters.search) {
+    apiFilters.push(parseQuery(cliFilters.search));
+  }
+
+  return {
+    filters: apiFilters,
+    debug,
+  };
+}
+
+/**
+ * Parse the sampling rate passed in via command line
+ *
+ * @param sampling_rate the sampling rate passed in via CLI
+ * @throws an Error if the rate doesn't make sense
+ * @returns a SamplingRateFilter for use with the API
+ */
+function parseSamplingRate(sampling_rate: number): SamplingRateFilter {
+  if (sampling_rate <= 0 || sampling_rate >= 1) {
+    throw new Error(
+      "A sampling rate must be between 0 and 1 in order to have any effect.\nFor example, a sampling rate of 0.25 means 25% of events will be logged."
+    );
+  }
+
+  return { sampling_rate };
+}
+
+/**
+ * Translate from CLI "status"es to API "outcome"s, including
+ * broadening "error" into "exception", "exceededCpu", and "unknown".
+ *
+ * @param statuses statuses passed in via CLI
+ * @returns an OutcomeFilter for use with the API
+ */
+function parseOutcome(
+  statuses: ("ok" | "error" | "canceled")[]
+): OutcomeFilter {
+  const outcomes = new Set<Outcome>();
+
+  for (const status of statuses) {
+    switch (status) {
+      case "ok":
+        outcomes.add("ok");
+        break;
+
+      case "canceled":
+        outcomes.add("canceled");
+        break;
+
+      case "error":
+        outcomes.add("exception");
+        outcomes.add("exceededCpu");
+        outcomes.add("unknown");
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  return {
+    outcome: Array.from(outcomes),
+  };
+}
+
+/**
+ * We just send silly methods through to the API anyway, since they don't
+ * cause any harm.
+ *
+ * @param method an array of HTTP request methods passed in via CLI
+ * @returns a MethodFilter for use with the API
+ */
+function parseMethod(method: string[]): MethodFilter {
+  return { method };
+}
+
+/**
+ * Header filters can contain either just a key ("X-HEADER-KEY") or both
+ * a key and a value ("X-HEADER-KEY:some-value"). This function parses
+ * a given string according to that pattern.
+ *
+ * @param header a header string, "X-HEADER-KEY" or "X-HEADER-KEY:some-value"
+ * @returns a HeaderFilter for use with the API
+ */
+function parseHeader(header: string): HeaderFilter {
+  const [headerKey, headerQuery] = header.split(":", 2);
+
+  return {
+    header: {
+      key: headerKey.trim(),
+      query: headerQuery?.trim(),
+    },
+  };
+}
+
+/**
+ * A list of IPs can be passed in to filter for messages that come from
+ * a worker triggered by a request originating from one of those IPs.
+ * You can also pass in the string "self" to filter for the IP of the
+ * machine running `wrangler tail`.
+ *
+ * @param client_ip an array of IP addresses to filter
+ * @returns a ClientIPFilter for use with the API
+ */
+function parseIP(client_ip: string[]): ClientIPFilter {
+  return { client_ip };
+}
+
+/**
+ * Users can filter for logs that contain a "search" or a "query string".
+ * For example, if `--search findme` is passed to then we will only
+ * receive logs that contain the string "findme".
+ *
+ * @param query a query string to search for
+ * @returns a QueryFilter for use with the API
+ */
+function parseQuery(query: string): QueryFilter {
+  return { query };
+}