alchemy 2.0.0-beta.65 → 2.0.0-beta.67

package/src/Bundle/Bundle.ts

@@ -4,7 +4,7 @@ import * as Queue from "effect/Queue";
 import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import assert from "node:assert";
-import * as rolldown from "rolldown";
+import type * as rolldown from "rolldown";
 import { sha256, sha256Object } from "../Util/sha256.ts";
 import {
   bundleAnalyzerPlugin,
@@ -13,6 +13,14 @@ import {
 import { purePlugin, type PurePluginOptions } from "./PurePlugin.ts";
 import { rawPlugin } from "./RawPlugin.ts";
 
+/**
+ * Rolldown is loaded lazily on first {@link build}/{@link watch} so that
+ * merely importing alchemy — the CLI command tree, the Cloudflare provider
+ * barrel — never loads `@rolldown/binding-*`. A stack that bundles
+ * nothing must not require the native bundler to be loadable (#562).
+ */
+const loadRolldown = () => import("rolldown");
+
 /**
  * Extra options accepted by {@link build} / {@link watch} on top of the
  * standard rolldown input/output options.
@@ -148,9 +156,10 @@ export const build = (
 ): Effect.Effect<BundleOutput, BundleError> =>
   Effect.tryPromise({
     try: async () => {
+      const rolldown = await loadRolldown();
       const bundle = await rolldown.rolldown({
         ...withAlchemyDefine(inputOptions),
-        plugins: [inputOptions.plugins, builtInPlugins(extra)],
+        plugins: [inputOptions.plugins, await builtInPlugins(extra)],
         optimization: inputOptions.optimization ?? {
           inlineConst: {
             mode: "smart",
@@ -188,12 +197,13 @@ export const watch = (
       }
   >((queue) =>
     Effect.acquireRelease(
-      Effect.sync(() => {
+      Effect.promise(async () => {
+        const rolldown = await loadRolldown();
         const watcher = rolldown.watch({
           ...withAlchemyDefine(inputOptions),
           plugins: [
             inputOptions.plugins,
-            builtInPlugins(extra),
+            await builtInPlugins(extra),
             // The watcher event listener does not receive the bundle output, so we grab it using a plugin.
             {
               name: "alchemy:watch-bundle",
@@ -348,12 +358,12 @@ export function bundleOutputFromRolldownOutputBundle(
  * `node_modules/<pkg>/...` by upstream resolver plugins such as
  * `@distilled.cloud/cloudflare-rolldown-plugin`.
  */
-function builtInPlugins(
+async function builtInPlugins(
   extra?: BundleExtraOptions,
-): rolldown.RolldownPluginOption {
+): Promise<rolldown.RolldownPluginOption> {
   return [
     extra?.bundleAnalyzer
-      ? bundleAnalyzerPlugin(
+      ? await bundleAnalyzerPlugin(
           extra.bundleAnalyzer === true ? {} : extra.bundleAnalyzer,
         )
       : undefined,

package/src/Bundle/BundleAnalyzerPlugin.ts

@@ -1,5 +1,4 @@
 import type { Plugin } from "rolldown";
-import { bundleAnalyzerPlugin as rolldownBundleAnalyzerPlugin } from "rolldown/experimental";
 
 export interface BundleAnalyzerPluginOptions {
   /**
@@ -24,10 +23,16 @@ export interface BundleAnalyzerPluginOptions {
  * - import dependencies between chunks
  * - the modules reachable from each entry point
  */
-export const bundleAnalyzerPlugin = (
+export const bundleAnalyzerPlugin = async (
   options: BundleAnalyzerPluginOptions = {},
-): Plugin =>
-  rolldownBundleAnalyzerPlugin({
+): Promise<Plugin> => {
+  // `rolldown/experimental` loads `@rolldown/binding-*` at module scope,
+  // so it is imported lazily — importing this module (e.g. via the
+  // `alchemy/Bundle` barrel) must never load the native binding (#562).
+  const { bundleAnalyzerPlugin: rolldownBundleAnalyzerPlugin } =
+    await import("rolldown/experimental");
+  return rolldownBundleAnalyzerPlugin({
     fileName: options.fileName,
     format: options.format ?? "md",
   });
+};

package/src/Bundle/PurePlugin.ts

@@ -13,8 +13,15 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import picomatch from "picomatch";
 import type * as rolldown from "rolldown";
-import { RolldownMagicString } from "rolldown";
-import { parseAst } from "rolldown/parseAst";
+
+/**
+ * `rolldown` and `rolldown/parseAst` load `@rolldown/binding-*` at module
+ * scope, so they are imported lazily on first use — importing this module
+ * (e.g. via the `alchemy/Bundle` barrel) must never load the native
+ * binding (#562).
+ */
+const loadRolldown = () => import("rolldown");
+const loadParseAst = () => import("rolldown/parseAst");
 
 /**
  * Default packages whose modules will receive `/*#__PURE__*\/` annotations.
@@ -149,7 +156,7 @@ export const purePlugin = (
         const markSideEffectFree =
           markSideEffectFreeOpt && !isEntry && sideEffectFreePkg;
 
-        const anchors = collectPureAnchorsCached(code, cleanId);
+        const anchors = await collectPureAnchorsCached(code, cleanId);
         // Annotating a call whose result is BOUND (variable initializer,
         // export) only lets the minifier drop it when the binding itself
         // is unused — safe everywhere. Annotating a call whose result is
@@ -175,7 +182,9 @@ export const purePlugin = (
         // `code`. Returning it as `code` hands sourcemap generation to
         // rolldown's native side (computed on a background thread). The
         // fallback covers direct hook invocations (unit tests).
-        const s = meta.magicString ?? new RolldownMagicString(code);
+        const s =
+          meta.magicString ??
+          new (await loadRolldown()).RolldownMagicString(code);
         for (const anchor of positions) s.appendLeft(anchor, PURE_COMMENT);
         return {
           code: s,
@@ -342,15 +351,15 @@ const anchorsCache = new Map<
 >();
 const ANCHORS_CACHE_MAX = 10_000;
 
-const collectPureAnchorsCached = (
+const collectPureAnchorsCached = async (
   code: string,
   filename: string,
-): PureAnchors | null => {
+): Promise<PureAnchors | null> => {
   const cached = anchorsCache.get(filename);
   if (cached !== undefined && cached.code === code) {
     return cached.anchors;
   }
-  const anchors = collectPureAnchors(code, filename);
+  const anchors = await collectPureAnchors(code, filename);
   if (anchorsCache.size >= ANCHORS_CACHE_MAX) {
     anchorsCache.clear();
   }
@@ -386,10 +395,11 @@ export interface PureAnchors {
  * Returns `null` if the file does not need to be modified (parse failure
  * or no annotations needed).
  */
-export function collectPureAnchors(
+export async function collectPureAnchors(
   code: string,
   filename: string,
-): PureAnchors | null {
+): Promise<PureAnchors | null> {
+  const { parseAst } = await loadParseAst();
   let program: Program;
   try {
     // Use TS lang so the parser tolerates TS syntax (`as`, `satisfies`,

package/src/Cli/checkVersion.ts

@@ -1,12 +1,30 @@
+import * as Clock from "effect/Clock";
+import * as Console from "effect/Console";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
 import * as HttpClient from "effect/unstable/http/HttpClient";
 
+import { AlchemyContext } from "alchemy/AlchemyContext";
 import packageJson from "../../package.json" with { type: "json" };
 
 const NPM_DIST_TAGS_URL =
   "https://registry.npmjs.org/-/package/alchemy/dist-tags";
 
+const CACHE_FILE = "version-check.json";
+const CACHE_TTL_MILLIS = Duration.toMillis(Duration.days(1));
+// npm's dist-tags endpoint is CDN-backed and typically answers in ~100ms;
+// the sync budget only needs to absorb a slow handshake, not a dead network.
+const SYNC_WAIT = Duration.seconds(3);
+
+interface VersionCheckCache {
+  checkedAt: number;
+  /** Absent when the last check attempt failed (offline, timeout, …). */
+  distTags?: Record<string, string>;
+}
+
 /**
  * Pick the dist-tag matching the current channel. For pre-release versions
  * like `2.0.0-beta.33`, npm's `latest` tag points at the most recent stable
@@ -26,32 +44,100 @@ const pickDistTag = (
   return distTags.latest;
 };
 
+const readCache = Effect.fn(
+  function* (cachePath: string) {
+    const fs = yield* FileSystem.FileSystem;
+    const raw = yield* fs.readFileString(cachePath);
+    const parsed = yield* Effect.try(
+      () => JSON.parse(raw) as VersionCheckCache | null | undefined,
+    );
+    return typeof parsed?.checkedAt === "number" ? parsed : undefined;
+  },
+  Effect.catch(() => Effect.succeed(undefined)),
+);
+
+const writeCache = Effect.fn(
+  function* (cachePath: string, distTags?: Record<string, string>) {
+    const fs = yield* FileSystem.FileSystem;
+    const checkedAt = yield* Clock.currentTimeMillis;
+    const cache: VersionCheckCache = { checkedAt, distTags };
+    yield* fs.writeFileString(cachePath, JSON.stringify(cache));
+  },
+  Effect.catch(() => Effect.void),
+);
+
+const fetchDistTags = Effect.gen(function* () {
+  const http = yield* HttpClient.HttpClient;
+  const response = yield* http.get(NPM_DIST_TAGS_URL);
+  const distTags = (yield* response.json) as Record<string, string> | null;
+  if (typeof distTags !== "object" || distTags === null) {
+    return yield* Effect.fail(new Error("malformed dist-tags response"));
+  }
+  return distTags;
+});
+
+/**
+ * Refresh the dist-tags cache with a single request. The fetch is forked so
+ * it outlives the sync wait: we give it {@link SYNC_WAIT} to land inline,
+ * and if it's still in flight the same request keeps going in the
+ * background, writing the cache when it completes. The background path
+ * never logs, so it can't interleave with prompts.
+ */
+const refreshDistTags = Effect.fn(function* (cachePath: string) {
+  const fetch = yield* fetchDistTags.pipe(
+    // The fiber owns all cache writes, whenever it completes — even after
+    // the sync wait below has given up on it. A failed attempt is cached
+    // too (a bare checkedAt), so a dead network costs at most one blocking
+    // wait per TTL window, not one per run.
+    Effect.tap((distTags) => writeCache(cachePath, distTags)),
+    Effect.tapError(() => writeCache(cachePath)),
+    Effect.forkScoped,
+  );
+  return yield* Fiber.join(fetch).pipe(
+    Effect.timeout(SYNC_WAIT),
+    Effect.catch(() => Effect.succeed(undefined)),
+  );
+});
+
 /**
- * Fetch the published `alchemy` version on the dist-tag matching the
- * current channel and log a warning if it's different from the bundled
- * version. Best-effort: any failure (offline, registry hiccup, slow
- * response) is swallowed silently.
+ * Warn if a newer `alchemy` version is published on the dist-tag matching
+ * the current channel. Runs to completion before any interactive prompts so
+ * the warning never interleaves with prompt rendering, and is bounded so it
+ * can never stall the CLI: dist-tags are cached in
+ * `.alchemy/version-check.json` for a day (failed attempts included), so at
+ * most one run per day waits on the network, and only up to
+ * {@link SYNC_WAIT}. Best-effort: every failure is swallowed silently.
  */
 export const checkLatestVersion = Effect.gen(function* () {
-  const http = yield* HttpClient.HttpClient;
-  const response = yield* http.get(NPM_DIST_TAGS_URL);
-  const distTags = (yield* response.json) as Record<string, string>;
-  if (typeof distTags !== "object" || distTags === null) return;
+  const path = yield* Path.Path;
+  const { dotAlchemy } = yield* AlchemyContext;
+  const cachePath = path.join(dotAlchemy, CACHE_FILE);
+  const now = yield* Clock.currentTimeMillis;
+
+  const cached = yield* readCache(cachePath);
+  const distTags =
+    cached !== undefined && now - cached.checkedAt <= CACHE_TTL_MILLIS
+      ? cached.distTags
+      : yield* refreshDistTags(cachePath);
+  if (distTags === undefined) return;
+
   const current = packageJson.version;
   const latest = pickDistTag(current, distTags);
-  if (typeof latest !== "string" || latest === current) return;
+  if (latest === undefined || latest === current) return;
+
   const installCmd =
     typeof process !== "undefined" && (process as any).versions?.bun
       ? `bun add alchemy@${latest}`
       : `pnpm add alchemy@${latest}`;
-  yield* Effect.logWarning(
+  // Print via the Console service, not Effect.logWarning: TelemetryLive
+  // replaces the default stdout logger with an OTLP-only logger at this
+  // stage of the program, so log output would never reach the terminal.
+  const useColor = process.stderr.isTTY === true;
+  const message =
     `alchemy ${latest} is available (you're on ${current}). ` +
-      `Run \`${installCmd}\` to upgrade.`,
-  );
-}).pipe(
-  Effect.timeout(Duration.seconds(5)),
-  Effect.catch(() => Effect.void),
-);
+    `Run \`${installCmd}\` to upgrade.`;
+  yield* Console.warn(useColor ? `\x1b[33m${message}\x1b[0m` : message);
+}).pipe(Effect.catch(() => Effect.void));
 
 // Exported for tests.
 export const _internal = { pickDistTag };

package/src/Cli/commands/_shared.ts

@@ -29,6 +29,7 @@ import { CloudflareAuth } from "../../Cloudflare/Auth/AuthProvider.ts";
 import { GitHubAuth } from "../../GitHub/AuthProvider.ts";
 import { NeonAuth } from "../../Neon/AuthProvider.ts";
 import { PlanetscaleAuth } from "../../Planetscale/AuthProvider.ts";
+import { PrismaAuth } from "../../Prisma/AuthProvider.ts";
 import * as Stack from "../../Stack.ts";
 import { Stage } from "../../Stage.ts";
 import { recordCli } from "../../Telemetry/Metrics.ts";
@@ -460,6 +461,7 @@ export const builtinAuth = Layer.mergeAll(
   GitHubAuth,
   NeonAuth,
   PlanetscaleAuth,
+  PrismaAuth,
 );
 
 /**

package/src/Cli/commands/deploy.ts

@@ -121,20 +121,9 @@ export const execStack = Effect.fn(function* ({
     const stack = yield* stackEffect;
 
     yield* Effect.gen(function* () {
-      const updatePlan = yield* Plan.make(
-        destroy
-          ? {
-              ...stack,
-              // zero these out (destroy will treat all as orphans)
-              // TODO(sam): probably better to have Plan.destroy and Plan.update
-              resources: {},
-              bindings: {},
-              actions: {},
-              output: {},
-            }
-          : stack,
-        { force },
-      );
+      const updatePlan = destroy
+        ? yield* Plan.destroy(stack)
+        : yield* Plan.make(stack, { force });
       if (dryRun) {
         yield* cli.displayPlan(updatePlan);
       } else {

package/src/Cli/commands/logs.ts

@@ -121,7 +121,12 @@ export const logsCommand = Command.make(
             });
             if (!(resourceState as any)?.attr) continue;
 
-            const provider = yield* findProviderByType(resource.Type);
+            // Query with the provider variant of the mode that deployed the
+            // row (a local dev worker's logs come from the local provider).
+            const provider = yield* findProviderByType(
+              resource.Type,
+              (resourceState as any).providerMode,
+            );
             if (!provider.logs) continue;
 
             const lines = yield* provider.logs({

package/src/Cli/commands/tail.ts

@@ -97,7 +97,12 @@ export const tailCommand = Command.make(
             });
             if (!(resourceState as any)?.attr) continue;
 
-            const provider = yield* findProviderByType(resource.Type);
+            // Tail with the provider variant of the mode that deployed the
+            // row (a local dev worker's logs come from the local provider).
+            const provider = yield* findProviderByType(
+              resource.Type,
+              (resourceState as any).providerMode,
+            );
             if (!provider.tail) continue;
 
             tailable.push({

package/src/Cli/main.ts

@@ -69,10 +69,11 @@ const services = Layer.mergeAll(
 );
 
 const program = Effect.gen(function* () {
-  // Best-effort, non-blocking check for a newer published version. If the
-  // CLI command finishes before the registry responds, the fiber is
-  // interrupted on scope close — that's intentional.
-  yield* checkLatestVersion.pipe(Effect.forkScoped);
+  // Best-effort check for a newer published version. Runs to completion
+  // before the command so the warning prints before any interactive
+  // prompts; the registry response is cached for a day and the fetch is
+  // bounded by a short timeout, so this stays fast.
+  yield* checkLatestVersion;
   return yield* cli;
 });
 

package/src/Cloudflare/AI/Search.ts

@@ -24,20 +24,12 @@ export type Parse = {
    * How pages are discovered:
    * - `"sitemap"` (default) — read `<seed>/sitemap.xml` (found via
    *   `robots.txt`) and index the URLs it lists.
-   * - `"crawl"` — start at `source` and follow links.
-   * - `"feed-rss"` — treat the seed as an RSS / Atom feed.
+   * - `"discover"` — start at `source` and follow links.
    * @default "sitemap"
    */
   type?: NonNullable<WebCrawlerParams["parseType"]>;
 } & NonNullable<WebCrawlerParams["parseOptions"]>;
 
-/**
- * Link-discovery options for a web crawler (mainly for `parse.type: "crawl"`):
- * `depth`, `includeSubdomains`, `includeExternalLinks`, `maxAge`, and `source`
- * (`"all"` | `"sitemaps"` | `"links"`).
- */
-export type Crawl = NonNullable<WebCrawlerParams["crawlOptions"]>;
-
 /**
  * Where crawled content is stored. Cloudflare provisions managed storage by
  * default; set this to store output in an R2 bucket you control.
@@ -94,7 +86,6 @@ export type R2Props = SharedProps & {
   /** R2 data-residency jurisdiction of the source bucket. */
   jurisdiction?: string;
   parse?: never;
-  crawl?: never;
   store?: never;
 };
 
@@ -107,8 +98,6 @@ export type WebCrawlerProps = SharedProps & {
   source: Input<string>;
   /** How pages are discovered and parsed. */
   parse?: Parse;
-  /** How links are followed from the seed. */
-  crawl?: Crawl;
   /** Where crawl output is stored (defaults to managed storage). */
   store?: Store;
   prefix?: never;
@@ -197,13 +186,12 @@ export type Search = SearchInstance & {
  *
  * @example Web-crawler source
  * Pass a URL as `source` to crawl and index a website (no service token
- * needed). `parse.type` defaults to `"sitemap"`; use `"crawl"` to follow
+ * needed). `parse.type` defaults to `"sitemap"`; use `"discover"` to follow
  * links from the seed instead.
  * ```typescript
  * const search = yield* Cloudflare.AI.Search("site-search", {
  *   source: "https://example.com",
- *   parse: { type: "crawl", contentSelector: [{ path: "/docs", selector: "main" }] },
- *   crawl: { depth: 3, includeSubdomains: true },
+ *   parse: { type: "discover", contentSelector: [{ path: "/docs", selector: "main" }] },
  * });
  * ```
  *
@@ -212,7 +200,7 @@ export type Search = SearchInstance & {
  * const store = yield* Cloudflare.R2.Bucket("crawl-store");
  * const search = yield* Cloudflare.AI.Search("site-search", {
  *   source: "https://example.com",
- *   parse: { type: "crawl" },
+ *   parse: { type: "discover" },
  *   store: { bucket: store },
  * });
  * ```
@@ -303,7 +291,6 @@ export const Search = (id: string, props: Props) =>
       exclude,
       jurisdiction,
       parse,
-      crawl,
       store,
       namespace,
       ...shared
@@ -359,7 +346,6 @@ export const Search = (id: string, props: Props) =>
       const webCrawler = clean({
         parseType,
         parseOptions: clean(parseOptions),
-        crawlOptions: crawl ? clean(crawl) : undefined,
         storeOptions: store
           ? clean({
               storageId: store.bucket.bucketName,

package/src/Cloudflare/AI/SearchInstance.ts

@@ -388,15 +388,10 @@ export type SearchInstance = Resource<
  * `parseType` selects how pages are discovered:
  * - `"sitemap"` (Cloudflare default) — read `<seed>/sitemap.xml` (discovered
  *   via `robots.txt`) and index the URLs it lists.
- * - `"crawl"` — start at `source` and follow links.
- * - `"feed-rss"` — treat the seed as an RSS / Atom feed.
+ * - `"discover"` — start at `source` and follow links.
  *
- * `crawlOptions` controls link discovery (mainly for `parseType: "crawl"`):
- * - `depth` — how many links deep to follow from the seed.
- * - `includeSubdomains` — also crawl subdomains of the seed host.
- * - `includeExternalLinks` — follow links off the seed host.
- * - `maxAge` — skip re-fetching pages younger than this (seconds).
- * - `source` — where links come from: `"all"`, `"sitemaps"`, or `"links"`.
+ * `crawlOptions` is no longer accepted by the API — Cloudflare removed it;
+ * discovery behavior is controlled solely by `parseType`.
  *
  * `parseOptions` controls how each page is parsed:
  * - `useBrowserRendering` — render JS in a headless browser before parsing.
@@ -416,7 +411,7 @@ export type SearchInstance = Resource<
  * const instance = yield* Cloudflare.AI.SearchInstance("site-search", {
  *   type: "web-crawler",
  *   source: "https://example.com",
- *   sourceParams: { webCrawler: { parseType: "crawl" } },
+ *   sourceParams: { webCrawler: { parseType: "discover" } },
  * });
  * ```
  * @example Fully-configured crawl
@@ -426,14 +421,7 @@ export type SearchInstance = Resource<
  *   source: "https://example.com",
  *   sourceParams: {
  *     webCrawler: {
- *       parseType: "crawl",
- *       crawlOptions: {
- *         depth: 3,
- *         includeSubdomains: true,
- *         includeExternalLinks: false,
- *         maxAge: 86_400,
- *         source: "all",
- *       },
+ *       parseType: "discover",
  *       parseOptions: {
  *         useBrowserRendering: true,
  *         includeImages: false,
@@ -443,7 +431,7 @@ export type SearchInstance = Resource<
  *   },
  * });
  * ```
- * @example Sitemap and RSS sources
+ * @example Sitemap source
  * ```typescript
  * // Index the URLs listed in one or more sitemaps (the default parse mode).
  * const fromSitemap = yield* Cloudflare.AI.SearchInstance("sitemap-search", {
@@ -456,13 +444,6 @@ export type SearchInstance = Resource<
  *     },
  *   },
  * });
- *
- * // Treat the seed as an RSS / Atom feed.
- * const fromFeed = yield* Cloudflare.AI.SearchInstance("feed-search", {
- *   type: "web-crawler",
- *   source: "https://example.com/feed.xml",
- *   sourceParams: { webCrawler: { parseType: "feed-rss" } },
- * });
  * ```
  * @example Store crawl output in a specific R2 bucket
  * ```typescript
@@ -471,7 +452,7 @@ export type SearchInstance = Resource<
  *   source: "https://example.com",
  *   sourceParams: {
  *     webCrawler: {
- *       parseType: "crawl",
+ *       parseType: "discover",
  *       storeOptions: { storageId: "my-crawl-bucket", storageType: "r2" },
  *     },
  *   },

package/src/Cloudflare/ApiToken/AccountApiToken.ts

@@ -53,6 +53,9 @@ export type AccountApiToken = Resource<
  * @section Creating a Token
  * @example A token for managing Workers and KV from CI
  * ```typescript
+ * // the account ID resolves from the profile you're deploying with
+ * const { accountId } = yield* yield* Cloudflare.CloudflareEnvironment;
+ *
  * const token = yield* Cloudflare.ApiToken.AccountApiToken("ci-token", {
  *   name: "my-ci-token",
  *   accountId,

package/src/Cloudflare/Auth/AuthProvider.ts

@@ -233,10 +233,23 @@ export const CloudflareAuth = AuthProviderLayer<
           ),
         );
         yield* Clank.info(
-          "Cloudflare: waiting for authorization (up to 5 minutes)...",
+          "Cloudflare: waiting for authorization (up to 5 minutes).",
         );
 
-        const credentials = yield* OAuthClient.callback(authorization);
+        const credentials = yield* Effect.raceFirst(
+          OAuthClient.callback(authorization),
+          Clank.text({
+            message: "Paste the authorization code or callback URL",
+            placeholder:
+              "The browser will complete this automatically when local",
+            validate: (value) =>
+              value.trim().length > 0 ? undefined : "Paste a code or URL",
+          }).pipe(
+            Effect.flatMap((input) =>
+              OAuthClient.exchangeCallbackInput(input, authorization),
+            ),
+          ),
+        );
         yield* store.write(profileName, "cf-oauth", credentials);
         yield* Clank.success("Cloudflare: OAuth credentials saved.");
         return credentials;
@@ -783,7 +796,8 @@ export const DEFAULT_SCOPES = [
 ];
 
 export const OAUTH_CLIENT_ID = "6d8c2255-0773-45f6-b376-2914632e6f91";
-export const OAUTH_REDIRECT_URI = "http://localhost:9976/auth/callback";
+export const OAUTH_REDIRECT_URI = "https://alchemy.run/auth/callback";
+export const OAUTH_LOCAL_CALLBACK_URI = "http://localhost:9976/auth/callback";
 export const OAUTH_ENDPOINTS = {
   authorize: "https://dash.cloudflare.com/oauth2/authorize",
   token: "https://dash.cloudflare.com/oauth2/token",