wrangler 0.0.0-e61907d → 0.0.0-e95bea2

package/src/dev/dev.tsx

@@ -0,0 +1,357 @@
+import { spawn } from "node:child_process";
+import { watch } from "chokidar";
+import clipboardy from "clipboardy";
+import commandExists from "command-exists";
+import { Box, Text, useApp, useInput } from "ink";
+import React, { useState, useEffect, useRef } from "react";
+import { withErrorBoundary, useErrorHandler } from "react-error-boundary";
+import onExit from "signal-exit";
+import tmp from "tmp-promise";
+import { fetch } from "undici";
+import { runCustomBuild } from "../entry";
+import openInBrowser from "../open-in-browser";
+import { reportError } from "../reporting";
+import { getAPIToken } from "../user";
+import { Local } from "./local";
+import { Remote } from "./remote";
+import { useEsbuild } from "./use-esbuild";
+import type { Config } from "../config";
+import type { Entry } from "../entry";
+import type { AssetPaths } from "../sites";
+import type { CfWorkerInit } from "../worker";
+
+export type DevProps = {
+  name?: string;
+  entry: Entry;
+  port?: number;
+  inspectorPort: number;
+  rules: Config["rules"];
+  accountId: undefined | string;
+  initialMode: "local" | "remote";
+  jsxFactory: undefined | string;
+  jsxFragment: undefined | string;
+  upstreamProtocol: "https" | "http";
+  localProtocol: "https" | "http";
+  enableLocalPersistence: boolean;
+  bindings: CfWorkerInit["bindings"];
+  public: undefined | string;
+  assetPaths: undefined | AssetPaths;
+  compatibilityDate: undefined | string;
+  compatibilityFlags: undefined | string[];
+  usageModel: undefined | "bundled" | "unbound";
+  buildCommand: {
+    command?: undefined | string;
+    cwd?: undefined | string;
+    watch_dir?: undefined | string;
+  };
+  env: string | undefined;
+  legacyEnv: boolean;
+  zone:
+    | {
+        id: string;
+        host: string;
+      }
+    | undefined;
+};
+
+export function DevImplementation(props: DevProps): JSX.Element {
+  const port = props.port ?? 8787;
+  const apiToken = props.initialMode === "remote" ? getAPIToken() : undefined;
+  const directory = useTmpDir();
+
+  useCustomBuild(props.entry, props.buildCommand);
+
+  if (props.public && props.entry.format === "service-worker") {
+    throw new Error(
+      "You cannot use the service worker format with a `public` directory."
+    );
+  }
+
+  if (props.bindings.wasm_modules && props.entry.format === "modules") {
+    throw new Error(
+      "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"
+    );
+  }
+
+  if (props.bindings.text_blobs && props.entry.format === "modules") {
+    throw new Error(
+      "You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[build.upload.rules]` in your wrangler.toml"
+    );
+  }
+
+  const bundle = useEsbuild({
+    entry: props.entry,
+    destination: directory,
+    staticRoot: props.public,
+    jsxFactory: props.jsxFactory,
+    rules: props.rules,
+    jsxFragment: props.jsxFragment,
+    serveAssetsFromWorker: !!props.public,
+  });
+
+  const toggles = useHotkeys(
+    {
+      local: props.initialMode === "local",
+      tunnel: false,
+    },
+    port,
+    props.inspectorPort,
+    props.localProtocol
+  );
+
+  useTunnel(toggles.tunnel);
+
+  return (
+    <>
+      {toggles.local ? (
+        <Local
+          name={props.name}
+          bundle={bundle}
+          format={props.entry.format}
+          bindings={props.bindings}
+          assetPaths={props.assetPaths}
+          public={props.public}
+          port={port}
+          rules={props.rules}
+          inspectorPort={props.inspectorPort}
+          enableLocalPersistence={props.enableLocalPersistence}
+        />
+      ) : (
+        <Remote
+          name={props.name}
+          bundle={bundle}
+          format={props.entry.format}
+          accountId={props.accountId}
+          apiToken={apiToken}
+          bindings={props.bindings}
+          assetPaths={props.assetPaths}
+          public={props.public}
+          port={port}
+          localProtocol={props.localProtocol}
+          inspectorPort={props.inspectorPort}
+          compatibilityDate={props.compatibilityDate}
+          compatibilityFlags={props.compatibilityFlags}
+          usageModel={props.usageModel}
+          env={props.env}
+          legacyEnv={props.legacyEnv}
+          zone={props.zone}
+        />
+      )}
+      <Box borderStyle="round" paddingLeft={1} paddingRight={1}>
+        <Text>
+          {`B to open a browser, D to open Devtools, L to ${
+            toggles.local ? "turn off" : "turn on"
+          } local mode, X to exit`}
+        </Text>
+      </Box>
+    </>
+  );
+}
+
+export interface DirectorySyncResult {
+  name: string;
+  removeCallback: () => void;
+}
+
+function useTmpDir(): string | undefined {
+  const [directory, setDirectory] = useState<DirectorySyncResult>();
+  const handleError = useErrorHandler();
+  useEffect(() => {
+    let dir: DirectorySyncResult | undefined;
+    try {
+      dir = tmp.dirSync({ unsafeCleanup: true });
+      setDirectory(dir);
+      return;
+    } catch (err) {
+      console.error("failed to create tmp dir");
+      handleError(err);
+    }
+    return () => {
+      dir?.removeCallback();
+    };
+  }, [handleError]);
+  return directory?.name;
+}
+
+function useCustomBuild(
+  expectedEntry: Entry,
+  build: {
+    command?: undefined | string;
+    cwd?: undefined | string;
+    watch_dir?: undefined | string;
+  }
+): void {
+  useEffect(() => {
+    if (!build.command) return;
+    let watcher: ReturnType<typeof watch> | undefined;
+    if (build.watch_dir) {
+      watcher = watch(build.watch_dir, {
+        persistent: true,
+        ignoreInitial: true,
+      }).on("all", (_event, filePath) => {
+        //TODO: we should buffer requests to the proxy until this completes
+        console.log(`The file ${filePath} changed, restarting build...`);
+        runCustomBuild(expectedEntry.file, build).catch((err) => {
+          console.error("Custom build failed:", err);
+        });
+      });
+    }
+
+    return () => {
+      watcher?.close();
+    };
+  }, [build, expectedEntry.file]);
+}
+
+function sleep(period: number) {
+  return new Promise((resolve) => setTimeout(resolve, period));
+}
+const SLEEP_DURATION = 2000;
+// really need a first class api for this
+const hostNameRegex = /userHostname="(.*)"/g;
+async function findTunnelHostname() {
+  let hostName: string | undefined;
+  while (!hostName) {
+    try {
+      const resp = await fetch("http://localhost:8789/metrics");
+      const data = await resp.text();
+      const matches = Array.from(data.matchAll(hostNameRegex));
+      hostName = matches[0][1];
+    } catch (err) {
+      await sleep(SLEEP_DURATION);
+    }
+  }
+  return hostName;
+}
+
+/**
+ * Create a tunnel to the remote worker.
+ * We've disabled this for now until we figure out a better user experience.
+ */
+function useTunnel(toggle: boolean) {
+  const tunnel = useRef<ReturnType<typeof spawn>>();
+  const removeSignalExitListener = useRef<() => void>();
+  // TODO: test if cloudflared is available, if not
+  // point them to a url where they can get docs to install it
+  useEffect(() => {
+    async function startTunnel() {
+      if (toggle) {
+        try {
+          await commandExists("cloudflared");
+        } catch (e) {
+          console.error(
+            "To share your worker on the Internet, please install `cloudflared` from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation"
+          );
+          return;
+        }
+        console.log("⎔ Starting a tunnel...");
+        tunnel.current = spawn("cloudflared", [
+          "tunnel",
+          "--url",
+          "http://localhost:8787",
+          "--metrics",
+          "localhost:8789",
+        ]);
+
+        tunnel.current.on("close", (code) => {
+          if (code) {
+            console.log(`Tunnel process exited with code ${code}`);
+          }
+        });
+
+        removeSignalExitListener.current = onExit((_code, _signal) => {
+          console.log("⎔ Shutting down local tunnel.");
+          tunnel.current?.kill();
+          tunnel.current = undefined;
+        });
+
+        const hostName = await findTunnelHostname();
+        await clipboardy.write(hostName);
+        console.log(`⬣ Sharing at ${hostName}, copied to clipboard.`);
+      }
+    }
+
+    startTunnel().catch(async (err) => {
+      console.error("tunnel:", err);
+      await reportError(err);
+    });
+
+    return () => {
+      if (tunnel.current) {
+        console.log("⎔ Shutting down tunnel.");
+        tunnel.current?.kill();
+        tunnel.current = undefined;
+        removeSignalExitListener.current && removeSignalExitListener.current();
+        removeSignalExitListener.current = undefined;
+      }
+    };
+  }, [toggle]);
+}
+
+type useHotkeysInitialState = {
+  local: boolean;
+  tunnel: boolean;
+};
+function useHotkeys(
+  initial: useHotkeysInitialState,
+  port: number,
+  inspectorPort: number,
+  localProtocol: "http" | "https"
+) {
+  // UGH, we should put port in context instead
+  const [toggles, setToggles] = useState(initial);
+  useInput(
+    async (
+      input,
+      // eslint-disable-next-line unused-imports/no-unused-vars
+      key
+    ) => {
+      switch (input.toLowerCase()) {
+        // open browser
+        case "b": {
+          await openInBrowser(`${localProtocol}://localhost:${port}`);
+          break;
+        }
+        // toggle inspector
+        case "d": {
+          await openInBrowser(
+            `https://built-devtools.pages.dev/js_app?experiments=true&v8only=true&ws=localhost:${inspectorPort}/ws`,
+            { forceChromium: true }
+          );
+          break;
+        }
+        // toggle local
+        case "l":
+          setToggles((previousToggles) => ({
+            ...previousToggles,
+            local: !previousToggles.local,
+          }));
+          break;
+        // shut down
+        case "q":
+        case "x":
+          process.exit(0);
+          break;
+        default:
+          // nothing?
+          break;
+      }
+    }
+  );
+  return toggles;
+}
+
+function ErrorFallback(props: { error: Error }) {
+  const { exit } = useApp();
+  useEffect(() => exit(props.error));
+  return (
+    <>
+      <Text>Something went wrong:</Text>
+      <Text>{props.error.stack}</Text>
+    </>
+  );
+}
+
+export default withErrorBoundary(DevImplementation, {
+  FallbackComponent: ErrorFallback,
+});

package/src/dev/local.tsx

@@ -0,0 +1,241 @@
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { useState, useEffect, useRef } from "react";
+import onExit from "signal-exit";
+import useInspector from "../inspect";
+import { DEFAULT_MODULE_RULES } from "../module-collection";
+import { waitForPortToBeAvailable } from "../proxy";
+import type { Config } from "../config";
+import type { AssetPaths } from "../sites";
+import type { CfWorkerInit, CfScriptFormat } from "../worker";
+import type { EsbuildBundle } from "./use-esbuild";
+
+export function Local(props: {
+  name: undefined | string;
+  bundle: EsbuildBundle | undefined;
+  format: CfScriptFormat | undefined;
+  bindings: CfWorkerInit["bindings"];
+  assetPaths: undefined | AssetPaths;
+  public: undefined | string;
+  port: number;
+  rules: Config["rules"];
+  inspectorPort: number;
+  enableLocalPersistence: boolean;
+}) {
+  const { inspectorUrl } = useLocalWorker({
+    name: props.name,
+    bundle: props.bundle,
+    format: props.format,
+    bindings: props.bindings,
+    assetPaths: props.assetPaths,
+    public: props.public,
+    port: props.port,
+    rules: props.rules,
+    enableLocalPersistence: props.enableLocalPersistence,
+  });
+  useInspector({
+    inspectorUrl,
+    port: props.inspectorPort,
+    logToTerminal: false,
+  });
+  return null;
+}
+
+function useLocalWorker(props: {
+  name: undefined | string;
+  bundle: EsbuildBundle | undefined;
+  rules: Config["rules"];
+  format: CfScriptFormat | undefined;
+  bindings: CfWorkerInit["bindings"];
+  assetPaths: undefined | AssetPaths;
+  public: undefined | string;
+  port: number;
+  enableLocalPersistence: boolean;
+}) {
+  // TODO: pass vars via command line
+  const { bundle, format, bindings, port, assetPaths } = props;
+  const local = useRef<ReturnType<typeof spawn>>();
+  const removeSignalExitListener = useRef<() => void>();
+  const [inspectorUrl, setInspectorUrl] = useState<string | undefined>();
+  useEffect(() => {
+    async function startLocalWorker() {
+      if (!bundle || !format) return;
+
+      // port for the worker
+      await waitForPortToBeAvailable(port, { retryPeriod: 200, timeout: 2000 });
+
+      if (props.public) {
+        throw new Error(
+          '⎔ A "public" folder is not yet supported in local mode.'
+        );
+      }
+
+      // In local mode, we want to copy all referenced modules into
+      // the output bundle directory before starting up
+      for (const module of bundle.modules) {
+        await writeFile(
+          path.join(path.dirname(bundle.path), module.name),
+          module.content
+        );
+      }
+
+      console.log("⎔ Starting a local server...");
+      // TODO: just use execa for this
+      local.current = spawn(
+        "node",
+        [
+          "--experimental-vm-modules",
+          "--inspect",
+          require.resolve("miniflare/cli"),
+          realpathSync(bundle.path),
+          "--watch",
+          "--wrangler-config",
+          path.join(__dirname, "../miniflare-config-stubs/wrangler.empty.toml"),
+          "--env",
+          path.join(__dirname, "../miniflare-config-stubs/.env.empty"),
+          "--package",
+          path.join(__dirname, "../miniflare-config-stubs/package.empty.json"),
+          "--port",
+          port.toString(),
+          ...(assetPaths
+            ? [
+                "--site",
+                path.join(process.cwd(), assetPaths.baseDirectory),
+                ...assetPaths.includePatterns.map((pattern) => [
+                  "--site-include",
+                  pattern,
+                ]),
+                ...assetPaths.excludePatterns.map((pattern) => [
+                  "--site-exclude",
+                  pattern,
+                ]),
+              ].flatMap((x) => x)
+            : []),
+          ...(props.enableLocalPersistence
+            ? ["--kv-persist", "--cache-persist", "--do-persist"]
+            : []),
+          ...Object.entries(bindings.vars || {}).flatMap(([key, value]) => {
+            return ["--binding", `${key}=${value}`];
+          }),
+          ...(bindings.kv_namespaces || []).flatMap(({ binding }) => {
+            return ["--kv", binding];
+          }),
+          ...(bindings.durable_objects?.bindings || []).flatMap(
+            ({ name, class_name }) => {
+              return ["--do", `${name}=${class_name}`];
+            }
+          ),
+          ...Object.entries(bindings.wasm_modules || {}).flatMap(
+            ([name, filePath]) => {
+              return [
+                "--wasm",
+                `${name}=${path.join(process.cwd(), filePath)}`,
+              ];
+            }
+          ),
+          ...bundle.modules.reduce<string[]>((cmd, { name, type }) => {
+            if (format === "service-worker") {
+              if (type === "compiled-wasm") {
+                // In service-worker format, .wasm modules are referenced
+                // by global identifiers, so we convert it here.
+                // This identifier has to be a valid JS identifier,
+                // so we replace all non alphanumeric characters
+                // with an underscore.
+                const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
+                return cmd.concat([`--wasm`, `${identifier}=${name}`]);
+              } else {
+                // TODO: we should actually support this
+                throw new Error(
+                  `⎔ Unsupported module type ${type} for file ${name} in service-worker format`
+                );
+              }
+            }
+            return cmd;
+          }, []),
+          "--modules",
+          String(format === "modules"),
+          ...(props.rules || [])
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            .concat(DEFAULT_MODULE_RULES!)
+            .flatMap((rule) =>
+              rule.globs.flatMap((glob) => [
+                "--modules-rule",
+                `${rule.type}=${glob}`,
+              ])
+            ),
+        ],
+        {
+          cwd: path.dirname(realpathSync(bundle.path)),
+        }
+      );
+      console.log(`⬣ Listening at http://localhost:${port}`);
+
+      local.current.on("close", (code) => {
+        if (code) {
+          console.log(`miniflare process exited with code ${code}`);
+        }
+      });
+
+      local.current.stdout?.on("data", (data: Buffer) => {
+        console.log(`${data.toString()}`);
+      });
+
+      local.current.stderr?.on("data", (data: Buffer) => {
+        console.error(`${data.toString()}`);
+        const matches =
+          /Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[A-Za-z0-9-]+)/.exec(
+            data.toString()
+          );
+        if (matches) {
+          setInspectorUrl(matches[1]);
+        }
+      });
+
+      local.current.on("exit", (code) => {
+        if (code) {
+          console.error(`miniflare process exited with code ${code}`);
+        }
+      });
+
+      local.current.on("error", (error: Error) => {
+        console.error(`miniflare process failed to spawn`);
+        console.error(error);
+      });
+
+      removeSignalExitListener.current = onExit((_code, _signal) => {
+        console.log("⎔ Shutting down local server.");
+        local.current?.kill();
+        local.current = undefined;
+      });
+    }
+
+    startLocalWorker().catch((err) => {
+      console.error("local worker:", err);
+    });
+
+    return () => {
+      if (local.current) {
+        console.log("⎔ Shutting down local server.");
+        local.current?.kill();
+        local.current = undefined;
+        removeSignalExitListener.current && removeSignalExitListener.current();
+        removeSignalExitListener.current = undefined;
+      }
+    };
+  }, [
+    bundle,
+    format,
+    port,
+    bindings.durable_objects?.bindings,
+    bindings.kv_namespaces,
+    bindings.vars,
+    props.enableLocalPersistence,
+    assetPaths,
+    props.public,
+    props.rules,
+    bindings.wasm_modules,
+  ]);
+  return { inspectorUrl };
+}