alchemy 2.0.0-beta.64 → 2.0.0-beta.66

package/src/Cli/commands/nuke.ts

@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
 import { MinimumLogLevel } from "effect/References";
+import * as Schedule from "effect/Schedule";
 import { Command, Flag } from "effect/unstable/cli";
 import picomatch from "picomatch";
 
@@ -75,6 +76,26 @@ const timeoutFlag = Flag.integer("timeout").pipe(
   Flag.withDefault(120),
 );
 
+const independentFlag = Flag.boolean("independent").pipe(
+  Flag.withDescription(
+    "Delete every resource independently instead of in coordinated passes. " +
+      "In pass mode a single slow or hanging delete delays the next pass for " +
+      "everything; with --independent each resource retries its own delete " +
+      "with backoff, in parallel, until it succeeds or --retries is " +
+      "exhausted. Dependency violations resolve naturally as the blocking " +
+      "resources are deleted concurrently.",
+  ),
+  Flag.withDefault(false),
+);
+
+const retriesFlag = Flag.integer("retries").pipe(
+  Flag.withDescription(
+    "With --independent: retries per resource after the initial delete " +
+      "attempt (each attempt still bounded by --timeout). Default: 10.",
+  ),
+  Flag.withDefault(10),
+);
+
 interface DiscoveredProvider {
   id: string;
   provider: ProviderService;
@@ -262,6 +283,59 @@ const groupBy = <T>(items: T[], key: (item: T) => string): Map<string, T[]> => {
   return out;
 };
 
+const addEdge = (map: Map<string, Set<string>>, from: string, to: string) => {
+  const set = map.get(from) ?? new Set<string>();
+  set.add(to);
+  map.set(from, set);
+};
+
+/**
+ * Strongly-connected components of the type-level teardown-dependency graph
+ * (Tarjan). Components are emitted in reverse topological order of the
+ * condensation — every component's successors are emitted before it — so
+ * callers can compute layers by iterating the result backwards.
+ */
+const stronglyConnectedComponents = (
+  nodes: readonly string[],
+  successors: Map<string, Set<string>>,
+): string[][] => {
+  const index = new Map<string, number>();
+  const low = new Map<string, number>();
+  const onStack = new Set<string>();
+  const stack: string[] = [];
+  const components: string[][] = [];
+  let counter = 0;
+  const strongConnect = (v: string): void => {
+    index.set(v, counter);
+    low.set(v, counter);
+    counter += 1;
+    stack.push(v);
+    onStack.add(v);
+    for (const w of successors.get(v) ?? []) {
+      if (!index.has(w)) {
+        strongConnect(w);
+        low.set(v, Math.min(low.get(v)!, low.get(w)!));
+      } else if (onStack.has(w)) {
+        low.set(v, Math.min(low.get(v)!, index.get(w)!));
+      }
+    }
+    if (low.get(v) === index.get(v)) {
+      const component: string[] = [];
+      for (;;) {
+        const w = stack.pop()!;
+        onStack.delete(w);
+        component.push(w);
+        if (w === v) break;
+      }
+      components.push(component);
+    }
+  };
+  for (const v of nodes) {
+    if (!index.has(v)) strongConnect(v);
+  }
+  return components;
+};
+
 const nukeSession: ScopedPlanStatusSession = {
   emit: () => Effect.void,
   done: () => Effect.void,
@@ -278,6 +352,8 @@ const nukeCommand = Command.make(
     verbose: verboseFlag,
     concurrency: concurrencyFlag,
     timeout: timeoutFlag,
+    independent: independentFlag,
+    retries: retriesFlag,
     include: includeFlag,
     exclude: excludeFlag,
     filter: filterFlag,
@@ -295,6 +371,8 @@ const nukeCommand = Command.make(
       verbose,
       concurrency,
       timeout,
+      independent,
+      retries,
       include,
       exclude,
       filter,
@@ -476,69 +554,223 @@ const nukeCommand = Command.make(
       const emitDelete = (event: NukeUI.DeleteEvent) =>
         deleteUI ? Effect.sync(() => deleteUI.emit(event)) : Effect.void;
 
-      let remaining = targets;
+      // One delete attempt for a single resource, bounded by --timeout, with
+      // the failure cause logged to the stack's file logger. Failure stays on
+      // the error channel so callers can retry or fold it as they see fit.
+      const attemptDelete = (item: (typeof targets)[number]) =>
+        item.provider
+          .delete({
+            id: displayName(item.attr),
+            // Enumerated straight from the cloud, so there is no
+            // Alchemy namespace — an un-namespaced fqn is just the id.
+            fqn: displayName(item.attr),
+            instanceId: "",
+            olds: item.attr as never,
+            output: item.attr as never,
+            session: nukeSession,
+            bindings: [],
+            // Nuke is an explicit, operator-confirmed account
+            // teardown: allow destructive prerequisites (e.g.
+            // emptying a bucket) that normal destroys gate behind
+            // props such as `forceDestroy` — `olds` here is cloud
+            // Attributes, not the originally-deployed Props.
+            force: true,
+          })
+          .pipe(
+            Effect.timeout(`${timeout} seconds`),
+            Effect.tapCause((cause) =>
+              Effect.logWarning(
+                `nuke: delete failed for ${item.id} ${displayName(item.attr)}`,
+                cause,
+              ),
+            ),
+            Effect.provide(context),
+          );
+
+      const retrySchedule = Schedule.min([
+        Schedule.exponential("1 second"),
+        Schedule.spaced("15 seconds"),
+      ]);
+
       let pass = 0;
-      while (remaining.length > 0) {
-        pass += 1;
-        yield* emitDelete({ kind: "pass", pass });
-
-        const byType = groupBy(remaining, (t) => t.id);
-        const results = yield* Effect.all(
-          [...byType.values()].map((items) =>
-            Effect.all(
-              items.map((item) =>
-                item.provider
-                  .delete({
-                    id: displayName(item.attr),
-                    // Enumerated straight from the cloud, so there is no
-                    // Alchemy namespace — an un-namespaced fqn is just the id.
-                    fqn: displayName(item.attr),
-                    instanceId: "",
-                    olds: item.attr as never,
-                    output: item.attr as never,
-                    session: nukeSession,
-                    bindings: [],
-                    // Nuke is an explicit, operator-confirmed account
-                    // teardown: allow destructive prerequisites (e.g.
-                    // emptying a bucket) that normal destroys gate behind
-                    // props such as `forceDestroy` — `olds` here is cloud
-                    // Attributes, not the originally-deployed Props.
-                    force: true,
-                  })
-                  .pipe(
-                    Effect.timeout(`${timeout} seconds`),
-                    Effect.tapCause((cause) =>
-                      Effect.logWarning(
-                        `nuke: delete failed for ${item.id} ${displayName(item.attr)}`,
-                        cause,
+
+      // Delete one tier of resources to completion, returning the items
+      // that could not be deleted.
+      const runTier = (tier: typeof targets) =>
+        Effect.gen(function* () {
+          if (tier.length === 0) return [] as typeof targets;
+          if (independent) {
+            // Independent mode: no pass barrier. Every resource retries its
+            // own delete with capped exponential backoff, all in parallel
+            // (provider groups bounded by --concurrency, resources within a
+            // provider unbounded, matching pass mode). A dependency
+            // violation resolves on a later attempt once the blocking
+            // resource's concurrent delete lands — a hanging delete only
+            // ever stalls itself.
+            pass += 1;
+            yield* emitDelete({ kind: "pass", pass });
+            const results = yield* Effect.all(
+              [...groupBy(tier, (t) => t.id).values()].map((items) =>
+                Effect.all(
+                  items.map((item) =>
+                    attemptDelete(item).pipe(
+                      Effect.retry({ schedule: retrySchedule, times: retries }),
+                      Effect.matchCause({
+                        onSuccess: () => ({ item, ok: true as const }),
+                        onFailure: () => ({ item, ok: false as const }),
+                      }),
+                      // Only the final outcome is emitted, so the UI's
+                      // failure count reflects exhausted resources, not
+                      // transient attempts.
+                      Effect.tap((r) =>
+                        r.ok
+                          ? emitDelete({ kind: "deleted", id: item.id })
+                          : emitDelete({ kind: "failed", id: item.id }),
                       ),
                     ),
-                    Effect.provide(context),
-                    Effect.matchCause({
-                      onSuccess: () => ({ item, ok: true as const }),
-                      onFailure: () => ({ item, ok: false as const }),
-                    }),
-                    Effect.tap((r) =>
-                      r.ok
-                        ? emitDelete({ kind: "deleted", id: item.id })
-                        : emitDelete({ kind: "failed", id: item.id }),
+                  ),
+                  { concurrency: "unbounded" },
+                ),
+              ),
+              { concurrency },
+            );
+            return results.flat().flatMap((r) => (r.ok ? [] : [r.item]));
+          }
+          let remaining = tier;
+          while (remaining.length > 0) {
+            pass += 1;
+            yield* emitDelete({ kind: "pass", pass });
+
+            const byType = groupBy(remaining, (t) => t.id);
+            const results = yield* Effect.all(
+              [...byType.values()].map((items) =>
+                Effect.all(
+                  items.map((item) =>
+                    attemptDelete(item).pipe(
+                      Effect.matchCause({
+                        onSuccess: () => ({ item, ok: true as const }),
+                        onFailure: () => ({ item, ok: false as const }),
+                      }),
+                      Effect.tap((r) =>
+                        r.ok
+                          ? emitDelete({ kind: "deleted", id: item.id })
+                          : emitDelete({ kind: "failed", id: item.id }),
+                      ),
                     ),
                   ),
+                  { concurrency: "unbounded" },
+                ),
               ),
-              { concurrency: "unbounded" },
-            ),
-          ),
-          { concurrency },
-        );
+              { concurrency },
+            );
 
-        const failed = results.flat().flatMap((r) => (r.ok ? [] : [r.item]));
-        // No resource deleted this pass: dependencies can't resolve further,
-        // so stop instead of looping forever.
-        if (failed.length === remaining.length) {
-          remaining = failed;
-          break;
+            const failed = results
+              .flat()
+              .flatMap((r) => (r.ok ? [] : [r.item]));
+            // No resource deleted this pass: dependencies can't resolve
+            // further, so stop instead of looping forever.
+            if (failed.length === remaining.length) {
+              return failed;
+            }
+            remaining = failed;
+          }
+          return remaining;
+        });
+
+      // ---- Teardown-dependency ordering ---------------------------------
+      // Providers declare `nuke.dependsOn: [globs]` when their cloud-side
+      // teardown CONSUMES another type (e.g. SageMaker HyperPod deletes
+      // node ENIs by assuming the instance group's execution role inside
+      // the cluster's VPC — deleting the role or network mid-teardown
+      // wedges the cluster in `Deleting` forever). Edge A→B means every A
+      // must be fully GONE before any B is deleted. Only types present in
+      // the target set participate, so the constraint costs nothing when no
+      // dependent resources exist; declaration cycles collapse into one
+      // concurrent wave (handled by the intra-wave retry machinery) with a
+      // logged warning instead of failing.
+      const typeIds = [...new Set(targets.map((t) => t.id))];
+      const providerOfType = new Map(targets.map((t) => [t.id, t.provider]));
+      const successors = new Map<string, Set<string>>();
+      const predecessors = new Map<string, Set<string>>();
+      for (const id of typeIds) {
+        const globs = providerOfType.get(id)?.nuke?.dependsOn;
+        if (!globs || globs.length === 0) continue;
+        const matches = picomatch([...globs]);
+        for (const other of typeIds) {
+          if (other === id || !matches(other)) continue;
+          addEdge(successors, id, other);
+          addEdge(predecessors, other, id);
+        }
+      }
+
+      const components = stronglyConnectedComponents(typeIds, successors);
+      for (const component of components) {
+        if (component.length > 1) {
+          yield* Effect.logWarning(
+            `nuke: teardown-dependency cycle between ${component.join(", ")} — deleting them concurrently`,
+          ).pipe(Effect.provide(context));
+        }
+      }
+      const compOf = new Map<string, number>();
+      components.forEach((component, i) => {
+        for (const node of component) compOf.set(node, i);
+      });
+      // Layer each component: 0 for sources, else 1 + max predecessor
+      // layer. Tarjan emits components in reverse topological order, so
+      // iterating backwards visits predecessors before dependents.
+      const layerOfComp: number[] = new Array(components.length).fill(0);
+      for (let i = components.length - 1; i >= 0; i--) {
+        let layer = 0;
+        for (const node of components[i]!) {
+          for (const pred of predecessors.get(node) ?? []) {
+            const predComp = compOf.get(pred)!;
+            if (predComp !== i) {
+              layer = Math.max(layer, layerOfComp[predComp]! + 1);
+            }
+          }
+        }
+        layerOfComp[i] = layer;
+      }
+      const waves: string[][] = [];
+      components.forEach((component, i) => {
+        (waves[layerOfComp[i]!] ??= []).push(...component);
+      });
+
+      // ---- Execute waves -------------------------------------------------
+      const targetsOfType = groupBy(targets, (t) => t.id);
+      const remainingCount = new Map(
+        [...targetsOfType.entries()].map(([id, items]) => [id, items.length]),
+      );
+      const remaining: typeof targets = [];
+      const held: string[] = [];
+      for (const wave of waves) {
+        const runnable: typeof targets = [];
+        for (const typeId of wave) {
+          const items = targetsOfType.get(typeId) ?? [];
+          // A dependent type still has undeleted resources — deleting this
+          // type now could wedge their in-flight teardown, which is exactly
+          // what the ordering exists to prevent. Hold it back and report.
+          const blockers = [...(predecessors.get(typeId) ?? [])].filter(
+            (pred) =>
+              compOf.get(pred) !== compOf.get(typeId) &&
+              (remainingCount.get(pred) ?? 0) > 0,
+          );
+          if (blockers.length > 0) {
+            held.push(`${typeId} (blocked by ${blockers.join(", ")})`);
+            remaining.push(...items);
+            for (const item of items) {
+              yield* emitDelete({ kind: "failed", id: item.id });
+            }
+            continue;
+          }
+          runnable.push(...items);
+        }
+        const failed = yield* runTier(runnable);
+        remaining.push(...failed);
+        const failedOfType = groupBy(failed, (t) => t.id);
+        for (const typeId of new Set(runnable.map((t) => t.id))) {
+          remainingCount.set(typeId, failedOfType.get(typeId)?.length ?? 0);
         }
-        remaining = failed;
       }
 
       if (deleteUI) {
@@ -549,8 +781,15 @@ const nukeCommand = Command.make(
       const deleted = targets.length - remaining.length;
       yield* Console.log("");
       yield* Console.log(
-        `Deleted ${deleted} resource(s) over ${pass} pass(es).`,
+        independent
+          ? `Deleted ${deleted} resource(s).`
+          : `Deleted ${deleted} resource(s) over ${pass} pass(es).`,
       );
+      if (held.length > 0) {
+        yield* Console.log(
+          `Held back (their dependent types could not be fully deleted): ${held.join("; ")}`,
+        );
+      }
       if (remaining.length > 0) {
         yield* Console.log(
           `${remaining.length} resource(s) could not be deleted.`,

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",