alchemy 2.0.0-beta.44 → 2.0.0-beta.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-beta.44",
+  "version": "2.0.0-beta.45",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
@@ -291,16 +291,16 @@
     "@alchemy.run/node-utils": "0.0.4",
     "@aws-sdk/credential-providers": "^3.0.0",
     "@clack/prompts": "^0.11.0",
-    "@distilled.cloud/aws": "^0.21.5",
-    "@distilled.cloud/axiom": "^0.21.5",
-    "@distilled.cloud/cloudflare": "^0.21.5",
-    "@distilled.cloud/cloudflare-rolldown-plugin": "0.6.3",
-    "@distilled.cloud/cloudflare-runtime": "0.6.3",
-    "@distilled.cloud/cloudflare-vite-plugin": "0.6.3",
-    "@distilled.cloud/core": "^0.21.5",
-    "@distilled.cloud/neon": "^0.21.5",
-    "@distilled.cloud/planetscale": "^0.21.5",
-    "@effect/vitest": ">=4.0.0-beta.66 || >=4.0.0",
+    "@distilled.cloud/aws": "^0.22.1",
+    "@distilled.cloud/axiom": "^0.22.1",
+    "@distilled.cloud/cloudflare": "^0.22.1",
+    "@distilled.cloud/cloudflare-rolldown-plugin": "0.10.1",
+    "@distilled.cloud/cloudflare-runtime": "0.10.1",
+    "@distilled.cloud/cloudflare-vite-plugin": "0.10.1",
+    "@distilled.cloud/core": "^0.22.1",
+    "@distilled.cloud/neon": "^0.22.1",
+    "@distilled.cloud/planetscale": "^0.22.1",
+    "@effect/vitest": ">=4.0.0-beta.74 || >=4.0.0",
     "@libsql/client": "^0.17.0",
     "@octokit/rest": "^22.0.1",
     "@smithy/node-config-provider": "^4.0.0",
@@ -327,9 +327,10 @@
   "devDependencies": {
     "@clack/prompts": "^0.11.0",
     "@cloudflare/workers-types": "^4.20250805.0",
-    "@effect/platform-bun": ">=4.0.0-beta.66 || >=4.0.0",
-    "@effect/platform-node": ">=4.0.0-beta.66 || >=4.0.0",
-    "@effect/platform-node-shared": ">=4.0.0-beta.66 || >=4.0.0",
+    "@cloudflare/puppeteer": "^1.1.0",
+    "@effect/platform-bun": ">=4.0.0-beta.74 || >=4.0.0",
+    "@effect/platform-node": ">=4.0.0-beta.74 || >=4.0.0",
+    "@effect/platform-node-shared": ">=4.0.0-beta.74 || >=4.0.0",
     "@oxc-project/types": "^0.127.0",
     "@types/pg": "^8.11.0",
     "@types/aws-lambda": "^8.10.152",
@@ -339,7 +340,7 @@
     "@types/react": "^19.2.2",
     "@types/ws": "^8.18.1",
     "better-auth": "^1.6.2",
-    "effect": ">=4.0.0-beta.66 || >=4.0.0",
+    "effect": ">=4.0.0-beta.74 || >=4.0.0",
     "react-devtools-core": "^7.0.1",
     "solid-js": "latest",
     "tsconfig-paths": "^4.2.0",
@@ -349,12 +350,12 @@
     "ws": "^8.20.0"
   },
   "peerDependencies": {
-    "@effect/platform-bun": ">=4.0.0-beta.66 || >=4.0.0",
-    "@effect/platform-node": ">=4.0.0-beta.66 || >=4.0.0",
-    "@effect/sql-pg": ">=4.0.0-beta.66 || >=4.0.0",
+    "@effect/platform-bun": ">=4.0.0-beta.74 || >=4.0.0",
+    "@effect/platform-node": ">=4.0.0-beta.74 || >=4.0.0",
+    "@effect/sql-pg": ">=4.0.0-beta.74 || >=4.0.0",
     "drizzle-kit": ">=1.0.0-rc.1",
     "drizzle-orm": ">=1.0.0-rc.1",
-    "effect": ">=4.0.0-beta.66 || >=4.0.0",
+    "effect": ">=4.0.0-beta.74 || >=4.0.0",
     "vite": "^8.0.7",
     "ws": "^8.20.0"
   },

package/src/AWS/Lambda/Function.ts

@@ -5,8 +5,8 @@ import type { CreateFunctionRequest } from "@distilled.cloud/aws/lambda";
 import * as Lambda from "@distilled.cloud/aws/lambda";
 import { Region } from "@distilled.cloud/aws/Region";
 import type * as lambda from "aws-lambda";
-import * as Config from "effect/Config";
 import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
@@ -94,8 +94,45 @@ export interface FunctionProps extends PlatformProps {
     subnetIds: string[];
     securityGroupIds: string[];
   };
+  /**
+   * Maximum execution time before the function is forcibly terminated.
+   * Rounded up to whole seconds.
+   *
+   * @default 3 seconds (AWS Lambda default)
+   */
+  timeout?: Duration.Duration;
 }
 
+/**
+ * Normalize a {@link FunctionProps.timeout} to whole seconds.
+ *
+ * State JSON round-trips flatten a `Duration` to its `toJSON` shape
+ * (`{_id:"Duration",_tag:"Millis"|"Nanos"|"Infinity",...}`), which is not a
+ * valid `Duration.Input`. Reconstruct an input that `Duration.toSeconds`
+ * accepts before delegating.
+ */
+export const toTimeoutSeconds = (
+  timeout: Duration.Duration | undefined,
+): number | undefined => {
+  if (timeout === undefined) return undefined;
+  const json = timeout as {
+    _id?: unknown;
+    _tag?: "Millis" | "Nanos" | "Infinity" | "NegativeInfinity";
+    millis?: number;
+    nanos?: string;
+  };
+  const input: Duration.Input =
+    json._id === "Duration"
+      ? json._tag === "Millis"
+        ? json.millis!
+        : json._tag === "Nanos"
+          ? BigInt(json.nanos!)
+          : "Infinity"
+      : timeout;
+  const seconds = Duration.toSeconds(input);
+  return Number.isFinite(seconds) ? Math.max(1, Math.ceil(seconds)) : undefined;
+};
+
 export interface Function extends Resource<
   FunctionTypeId,
   FunctionProps,
@@ -368,7 +405,9 @@ export const Function: Platform<
       env,
       set: (id: string, output: Output.Output) =>
         Effect.sync(() => {
-          const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
+          // Key is already canonical (see RuntimeContext.sanitizeKey); store it
+          // verbatim.
+          const key = id;
           // Preserve `Redacted`-ness across the Output → Lambda env var
           // round-trip. `JSON.stringify(Redacted)` would emit the literal
           // string `"<redacted>"` and lose the value, so secrets are
@@ -387,34 +426,35 @@ export const Function: Platform<
           return key;
         }),
       get: <T>(key: string) =>
-        Config.string(key).pipe(
-          Effect.flatMap((val) =>
-            Effect.try({
-              try: () => {
-                const value = JSON.parse(val);
-                if (
-                  value !== null &&
-                  typeof value === "object" &&
-                  (value as { _tag?: unknown })._tag === "Redacted" &&
-                  "value" in (value as object)
-                ) {
-                  return Redacted.make(
-                    (value as { value: unknown }).value,
-                  ) as unknown as T;
-                }
-                return value as T;
-              },
-              catch: () => val, // assume it's just a string
-            }),
-          ),
-          Effect.catch((cause) =>
-            Effect.die(
-              new Error(`Failed to get environment variable: ${key}`, {
-                cause,
-              }),
-            ),
-          ),
-        ),
+        // Read the captured value straight from `process.env`. We must NOT
+        // resolve through `Config.string` here: at runtime the ambient
+        // `ConfigProvider` is the interceptor installed in `Platform.ts`,
+        // whose runtime branch calls back into `ctx.get(key)`. Going through
+        // `Config` would re-enter that interceptor for the same key and
+        // recurse forever, allocating until the Lambda init OOMs. The Worker
+        // runtime reads from `WorkerEnvironment` for the same reason.
+        Effect.sync(() => {
+          // Key is already canonical (see RuntimeContext.sanitizeKey).
+          const val = process.env[key];
+          if (val === undefined) {
+            return undefined;
+          }
+          try {
+            const value = JSON.parse(val);
+            if (
+              typeof value === "object" &&
+              value?._tag === "Redacted" &&
+              "value" in value
+            ) {
+              return Redacted.make(
+                (value as { value: unknown }).value,
+              ) as unknown as T;
+            }
+            return value as T;
+          } catch {
+            return val as unknown as T; // assume it's just a string
+          }
+        }),
       serve: (handler: HttpEffect) =>
         ctx.listen(makeFunctionHttpHandler(handler)),
       listen: ((
@@ -872,6 +912,7 @@ export default await Effect.runPromise(handlerEffect)
               }
             : undefined,
           Tags: tags,
+          Timeout: toTimeoutSeconds(news.timeout),
           VpcConfig: news.vpc
             ? {
                 SubnetIds: news.vpc.subnetIds,
@@ -1121,6 +1162,11 @@ export default await Effect.runPromise(handlerEffect)
             // code changed
             return { action: "update" };
           }
+          if (
+            toTimeoutSeconds(olds.timeout) !== toTimeoutSeconds(news.timeout)
+          ) {
+            return { action: "update" };
+          }
         }),
         read: Effect.fnUntraced(function* ({ id, olds, output }) {
           const functionName =
@@ -1161,7 +1207,7 @@ export default await Effect.runPromise(handlerEffect)
           // Reuse the persisted output where we have it (e.g. code hash) so
           // diff doesn't see drift it can't reconstruct from the API.
           const attrs = {
-            ...(output ?? {}),
+            ...output,
             functionArn: fn.FunctionArn,
             functionName: fn.FunctionName,
             functionUrl,
@@ -1185,8 +1231,15 @@ export default await Effect.runPromise(handlerEffect)
             vpc: news.vpc,
           });
 
-          // mock code
-          const code = new TextEncoder().encode("export default () => {}");
+          // Mock code for the pre-created stub. It responds 503 (rather than a
+          // bare 200) so that, during the brief window where the real
+          // code/config update is still `InProgress`, a Function URL hit serves
+          // an honest "not ready" signal instead of a successful-but-empty 200.
+          // Downstream readiness probes already retry on non-200, so they wait
+          // for the real handler to go live without the provider blocking.
+          const code = new TextEncoder().encode(
+            `export default () => ({ statusCode: 503, headers: { "content-type": "application/json" }, body: JSON.stringify({ error: "function initializing" }) })`,
+          );
           const archive = yield* zipCode(code);
           const hash = yield* hashBundle(code);
           yield* createOrUpdateFunction({
@@ -1261,7 +1314,7 @@ export default await Effect.runPromise(handlerEffect)
           yield* session.note(summary({ code }));
 
           return {
-            ...(output ?? {}),
+            ...output,
             functionArn,
             functionName,
             functionUrl: functionUrl as any,

package/src/AWS/Providers.ts

@@ -19,6 +19,7 @@ import * as HttpClientError from "effect/unstable/http/HttpClientError";
 import { CredentialsStoreLive } from "../Auth/Credentials.ts";
 import { Command, CommandProvider } from "../Build/Command.ts";
 import * as Provider from "../Provider.ts";
+import { KeyPair, KeyPairProvider } from "../KeyPair.ts";
 import { Random, RandomProvider } from "../Random.ts";
 import * as ACM from "./ACM/index.ts";
 import * as ApiGateway from "./ApiGateway/index.ts";
@@ -63,6 +64,7 @@ export const providers = () =>
     Providers,
     Provider.collection([
       Command,
+      KeyPair,
       Random,
       ACM.Certificate,
       ApiGateway.Account,
@@ -571,6 +573,7 @@ export const providers = () =>
     Layer.provideMerge(
       Layer.mergeAll(
         CommandProvider(),
+        KeyPairProvider(),
         RandomProvider(),
         Assets.AssetsProvider(),
       ),

package/src/Apply.ts

@@ -280,7 +280,24 @@ const executePlan = Effect.fnUntraced(function* (
     Effect.all(
       fqns
         .filter((fqn) => fqn in ready)
-        .map((fqn) => Deferred.await(ready[fqn])),
+        .map((fqn) =>
+          // Non-cycle upstreams must be observed at their TERMINAL output
+          // (`readyStable`), not their early precreate signal (`ready`). This
+          // is what makes a failed upstream actually interrupt its downstream:
+          // a resource with `precreate` resolves `ready` before its real
+          // `reconcile` runs, so a downstream waiting on `ready` would proceed
+          // (and even finish) even though the upstream's reconcile later
+          // failed. Waiting on `readyStable` means the downstream's
+          // `waitForDeps` short-circuits with the upstream's failure cause.
+          //
+          // Cycle members are the exception: peers in an SCC depend on each
+          // other, so they must rendezvous on the early `ready`/precreate
+          // signal to break the deadlock. Phase 3 (`converge`) re-runs them
+          // against final outputs once the cycle settles.
+          plan.cycleMembers.has(fqn)
+            ? Deferred.await(ready[fqn])
+            : Deferred.await(readyStable[fqn]),
+        ),
       { concurrency: "unbounded" },
     );
 

package/src/Auth/AuthProvider.ts

@@ -2,6 +2,7 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
+import * as Semaphore from "effect/Semaphore";
 import { withLock } from "./Lock.ts";
 
 /**
@@ -14,6 +15,20 @@ import { withLock } from "./Lock.ts";
  */
 const LOCKED_METHODS = new Set(["read", "login", "logout", "configure"]);
 
+/**
+ * Methods that may drive an interactive flow (prompts, browser-based
+ * OAuth, etc.). A process-wide mutex serializes these across providers
+ * so that, e.g., Cloudflare's `configure` finishes its prompt sequence
+ * before Planetscale's begins — even when the two auth provider Layers
+ * are built in parallel as part of a single `providers()` Layer.
+ *
+ * The clack prompt wrapper in `Util/Clank.ts` enforces per-prompt
+ * serialization; this mutex enforces per-flow serialization so the user
+ * sees one provider's prompts grouped together rather than interleaved.
+ */
+const INTERACTIVE_METHODS = new Set(["login", "configure"]);
+const interactiveMutex = Semaphore.makeUnsafe(1);
+
 export class AuthError extends Schema.TaggedErrorClass<AuthError>()(
   "AuthError",
   {
@@ -143,13 +158,18 @@ export const AuthProvider =
               Object.entries(service).map(([methodName, fn]) => [
                 methodName,
                 (...args: Parameters<typeof fn>) => {
-                  const eff = (fn as any)(...args).pipe(
+                  let eff = (fn as any)(...args).pipe(
                     Effect.provideContext(ctx),
                   );
-                  if (!LOCKED_METHODS.has(methodName)) return eff;
-                  // First positional arg is always `profileName`.
-                  const profileName = args[0] as string;
-                  return withLock(`${profileName}-${name}`, eff);
+                  if (LOCKED_METHODS.has(methodName)) {
+                    // First positional arg is always `profileName`.
+                    const profileName = args[0] as string;
+                    eff = withLock(`${profileName}-${name}`, eff);
+                  }
+                  if (INTERACTIVE_METHODS.has(methodName)) {
+                    eff = Semaphore.withPermits(interactiveMutex, 1)(eff);
+                  }
+                  return eff;
                 },
               ]),
             ),

package/src/Auth/Credentials.ts

@@ -70,13 +70,14 @@ export const CredentialsStoreLive = Layer.effect(
       credentials: T,
     ): Effect.Effect<void, PlatformError> => {
       const filePath = credentialsFilePath(profile, provider);
-      return fs
-        .makeDirectory(path.dirname(filePath), { recursive: true })
-        .pipe(
-          Effect.flatMap(() =>
-            fs.writeFileString(filePath, JSON.stringify(credentials, null, 2)),
-          ),
-        );
+      return fs.makeDirectory(path.dirname(filePath), { recursive: true }).pipe(
+        Effect.flatMap(() => {
+          return fs.writeFileString(
+            filePath,
+            JSON.stringify(credentials, null, 2),
+          );
+        }),
+      );
     };
 
     const remove_ = (profile: string, provider: string): Effect.Effect<void> =>

package/src/Cli/commands/_shared.ts

@@ -9,7 +9,12 @@ import * as Argument from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
 import * as Flag from "effect/unstable/cli/Flag";
 
-import { AuthError } from "../../Auth/AuthProvider.ts";
+import {
+  type AuthProvider,
+  AuthError,
+  AuthProviders,
+} from "../../Auth/AuthProvider.ts";
+import type { AlchemyProfile } from "../../Auth/Profile.ts";
 import type * as Stack from "../../Stack.ts";
 import { recordCli } from "../../Telemetry/Metrics.ts";
 import { PromptCancelled } from "../../Util/Clank.ts";
@@ -254,11 +259,49 @@ export const instrumentCommand =
       recordCli(command),
     );
 
+/**
+ * Render a profile's stored credential entries the same way across
+ * `alchemy login` and `alchemy profile show`: one `── Provider ──`
+ * header per entry, then either the provider's own `prettyPrint` block
+ * (preferred) or a JSON-style fallback when the provider isn't
+ * registered in the supplied {@link AuthProviders} registry.
+ */
+export const printProfile = Effect.fn(function* (
+  profile: string,
+  stored: AlchemyProfile,
+  registry: AuthProviders["Service"],
+) {
+  yield* Console.log(`Profile: ${profile}`);
+  const names = Object.keys(stored).sort();
+  if (names.length === 0) {
+    yield* Console.log("(no providers configured)");
+    return;
+  }
+  for (const name of names) {
+    const cfg = stored[name]!;
+    yield* Console.log("");
+    yield* Console.log(`── ${name} ──`);
+    const provider: AuthProvider | undefined = registry[name];
+    if (provider == null) {
+      yield* Console.log(`  method: ${cfg.method}`);
+      const { method: _method, ...rest } = cfg as Record<string, unknown> & {
+        method: string;
+      };
+      for (const [k, v] of Object.entries(rest)) {
+        yield* Console.log(
+          `  ${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`,
+        );
+      }
+      continue;
+    }
+    yield* provider.prettyPrint(profile, cfg);
+  }
+});
+
 export const importStack = Effect.fn(function* (main: string) {
   const path = yield* Path.Path;
-  const module = yield* Effect.promise(
-    () => import(path.resolve(process.cwd(), main)),
-  );
+  const url = import.meta.resolve(path.resolve(main));
+  const module = yield* Effect.promise(() => import(url));
   const stackEffect = module.default as ReturnType<
     ReturnType<typeof Stack.make>
   >;

package/src/Cli/commands/dev.ts

@@ -40,7 +40,12 @@ export const devCommand = Command.make(
           : [
               "node",
               ...process.execArgv,
-              "--experimental-transform-types",
+              ...(isTransformTypesSupported()
+                ? [
+                    "--experimental-transform-types",
+                    "--no-warnings=ExperimentalWarning",
+                  ]
+                : []),
               "--watch",
               "--watch-preserve-output",
               fileURLToPath(import.meta.resolve("alchemy/bin/exec.js")),
@@ -67,3 +72,10 @@ export const devCommand = Command.make(
       )(effect),
   ),
 );
+
+const isTransformTypesSupported = (
+  version = process.versions.node,
+): boolean => {
+  const [major, minor] = version.split(".").map(Number);
+  return (major === 22 && minor >= 7) || (major >= 23 && major < 26);
+};

package/src/Cli/commands/login.ts

@@ -18,6 +18,7 @@ import {
   envFile,
   importStack,
   instrumentCommand,
+  printProfile,
   profile,
   script,
   stage,
@@ -91,10 +92,12 @@ export const loginCommand = Command.make(
           (provider) =>
             Effect.gen(function* () {
               const existing = yield* profiles.getProfile(profile);
-              const stored = existing?.[provider.name];
+              // --configure treats every provider as missing, so configure
+              // runs unconditionally and overwrites the stored entry.
+              const stored = configure ? undefined : existing?.[provider.name];
 
               let cfg: { method: string };
-              if (configure || stored == null) {
+              if (stored == null) {
                 cfg = yield* provider.configure(profile, { ci });
                 yield* profiles.setProfile(profile, {
                   ...existing,
@@ -104,11 +107,24 @@ export const loginCommand = Command.make(
                 cfg = stored;
               }
 
-              yield* provider.login(profile, cfg);
-              yield* provider.prettyPrint(profile, cfg);
+              // `read` succeeds when creds are present and not expired
+              // (refreshing OAuth proactively if near expiry). Any failure
+              // — missing file, dead refresh token, etc. — falls through
+              // to `login`.
+              yield* provider
+                .read(profile, cfg)
+                .pipe(Effect.catch(() => provider.login(profile, cfg)));
             }),
           { discard: true },
         );
+
+        // Print the resulting profile using the same renderer as
+        // `alchemy profile show`.
+        const final = yield* profiles.getProfile(profile);
+        if (final != null) {
+          yield* Console.log("");
+          yield* printProfile(profile, final, authProviders);
+        }
       }).pipe(Effect.provide(services));
     }),
   ),

package/src/Cli/commands/profile.ts

@@ -9,11 +9,20 @@ import { AuthProviders } from "../../Auth/AuthProvider.ts";
 import { CredentialsStore } from "../../Auth/Credentials.ts";
 import { Profile, withProfileOverride } from "../../Auth/Profile.ts";
 import { AwsAuth } from "../../AWS/AuthProvider.ts";
+import { AxiomAuth } from "../../Axiom/AuthProvider.ts";
 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 { loadConfigProvider } from "../../Util/ConfigProvider.ts";
 import { fileLogger } from "../../Util/FileLogger.ts";
 
-import { envFile, instrumentCommand, profile } from "./_shared.ts";
+import {
+  envFile,
+  instrumentCommand,
+  printProfile,
+  profile,
+} from "./_shared.ts";
 
 const showCommand = Command.make(
   "show",
@@ -36,14 +45,6 @@ const showCommand = Command.make(
         return;
       }
 
-      yield* Console.log(`Profile: ${profile}`);
-
-      const providerNames = Object.keys(stored).sort();
-      if (providerNames.length === 0) {
-        yield* Console.log("(no providers configured)");
-        return;
-      }
-
       const authProviders: AuthProviders["Service"] = {};
       const authRegistry = Layer.succeed(AuthProviders, authProviders);
       const services = Layer.mergeAll(
@@ -54,33 +55,22 @@ const showCommand = Command.make(
         Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
         // Building these layers triggers their AuthProviderLayer effect, which
         // registers the provider into the shared `authProviders` registry.
-        Layer.provide(Layer.mergeAll(CloudflareAuth, AwsAuth), authRegistry),
+        Layer.provide(
+          Layer.mergeAll(
+            AwsAuth,
+            AxiomAuth,
+            CloudflareAuth,
+            GitHubAuth,
+            NeonAuth,
+            PlanetscaleAuth,
+          ),
+          authRegistry,
+        ),
       );
 
-      yield* Effect.gen(function* () {
-        for (const name of providerNames) {
-          const cfg = stored[name]!;
-          yield* Console.log("");
-          yield* Console.log(`── ${name} ──`);
-          const provider = authProviders[name];
-          if (provider == null) {
-            // Unknown provider — fall back to a JSON dump so the user can still
-            // see what's stored even if its module isn't bundled into the CLI.
-            yield* Console.log(`method: ${cfg.method}`);
-            const { method: _method, ...rest } = cfg as Record<
-              string,
-              unknown
-            > & { method: string };
-            for (const [k, v] of Object.entries(rest)) {
-              yield* Console.log(
-                `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`,
-              );
-            }
-            continue;
-          }
-          yield* provider.prettyPrint(profile, cfg);
-        }
-      }).pipe(Effect.provide(services));
+      yield* printProfile(profile, stored, authProviders).pipe(
+        Effect.provide(services),
+      );
     }),
   ),
 );

package/src/Cli/main.ts

@@ -8,12 +8,9 @@ import { AlchemyContextLive } from "alchemy/AlchemyContext";
 import { CredentialsStoreLive } from "alchemy/Auth/Credentials";
 import { ProfileLive } from "alchemy/Auth/Profile";
 import { TelemetryLive } from "alchemy/Telemetry/Layer";
-import { installLocalhostDns } from "alchemy/Util/LocalhostDns";
 import { PlatformServices } from "alchemy/Util/PlatformServices";
 import packageJson from "../../package.json" with { type: "json" };
 
-installLocalhostDns();
-
 import { checkLatestVersion } from "./checkVersion.ts";
 import { handleCancellation } from "./commands/_shared.ts";
 import { awsCommand } from "./commands/aws.ts";

package/src/Cloudflare/AiGateway/AiGateway.ts

@@ -190,8 +190,6 @@ export type AiGateway = Resource<
   {
     gatewayId: string;
     accountId: string;
-    accountTag: string | undefined;
-    internalId: string | undefined;
     cacheInvalidateOnUpdate: boolean;
     cacheTtl: number | null;
     collectLogs: boolean;
@@ -328,8 +326,8 @@ export const AiGatewayProvider = () =>
       ): AiGateway["Attributes"] => ({
         gatewayId: gateway.id,
         accountId,
-        accountTag: gateway.accountTag ?? undefined,
-        internalId: gateway.internalId ?? undefined,
+        // accountTag: gateway.accountTag ?? undefined,
+        // internalId: gateway.internalId ?? undefined,
         cacheInvalidateOnUpdate: gateway.cacheInvalidateOnUpdate,
         cacheTtl: nullIfZero(gateway.cacheTtl),
         collectLogs: gateway.collectLogs,
@@ -387,7 +385,6 @@ export const AiGatewayProvider = () =>
           rateLimitingLimit: next.rateLimitingLimit,
           rateLimitingTechnique: next.rateLimitingTechnique,
           authentication: next.authentication,
-          isDefault: next.isDefault,
           logManagement: next.logManagement,
           logManagementStrategy: next.logManagementStrategy,
           logpush: next.logpush,
@@ -413,7 +410,6 @@ export const AiGatewayProvider = () =>
           rateLimitingTechnique: next.rateLimitingTechnique,
           authentication: next.authentication,
           dlp: next.dlp,
-          isDefault: next.isDefault,
           logManagement: next.logManagement,
           logManagementStrategy: next.logManagementStrategy,
           logpush: next.logpush,