alchemy 2.0.0-beta.20 → 2.0.0-beta.21

package/bin/commands/bootstrap.ts

@@ -57,68 +57,70 @@ export const bootstrapCommand = Command.make(
       "alchemy.region": a.region ?? "",
       "alchemy.destroy": a.destroy,
     }),
-  )(Effect.fnUntraced(function* ({ envFile, profile, region, destroy }) {
-    const logger = Logger.layer([fileLogger("bootstrap.txt")]);
+  )(
+    Effect.fnUntraced(function* ({ envFile, profile, region, destroy }) {
+      const logger = Logger.layer([fileLogger("bootstrap.txt")]);
 
-    return yield* Effect.gen(function* () {
-      const ssoProfile = yield* Auth.loadProfile(profile);
-      if (!ssoProfile.sso_account_id) {
-        return yield* Effect.die(
-          `AWS SSO profile '${profile}' is missing sso_account_id`,
-        );
-      }
-
-      // Build a single AWSEnvironment, then derive Region/Credentials from
-      // it so resource providers downstream see a consistent view. The
-      // credentials Effect captures FileSystem/Path/HttpClient via the
-      // ambient context; AWSEnvironment expects R=never, so we provide it
-      // here.
-      const ambient = yield* Effect.context<FileSystem | Path | HttpClient>();
-      const environment = AWSEnvironment.makeEnvironment({
-        accountId: ssoProfile.sso_account_id,
-        region: region ?? ssoProfile.region ?? "us-east-1",
-        credentials: Auth.loadProfileCredentials(profile).pipe(
-          Effect.provide(ambient),
-        ),
-        profile,
-      });
+      return yield* Effect.gen(function* () {
+        const ssoProfile = yield* Auth.loadProfile(profile);
+        if (!ssoProfile.sso_account_id) {
+          return yield* Effect.die(
+            `AWS SSO profile '${profile}' is missing sso_account_id`,
+          );
+        }
 
-      const awsLayers = Layer.provideMerge(
-        Layer.mergeAll(
-          AWSRegion.fromEnvironment,
-          AWSCredentials.fromEnvironment,
-        ),
-        environment,
-      );
+        // Build a single AWSEnvironment, then derive Region/Credentials from
+        // it so resource providers downstream see a consistent view. The
+        // credentials Effect captures FileSystem/Path/HttpClient via the
+        // ambient context; AWSEnvironment expects R=never, so we provide it
+        // here.
+        const ambient = yield* Effect.context<FileSystem | Path | HttpClient>();
+        const environment = AWSEnvironment.makeEnvironment({
+          accountId: ssoProfile.sso_account_id,
+          region: region ?? ssoProfile.region ?? "us-east-1",
+          credentials: Auth.loadProfileCredentials(profile).pipe(
+            Effect.provide(ambient),
+          ),
+          profile,
+        });
 
-      return yield* Effect.gen(function* () {
-        const provider = yield* loadConfigProvider(envFile);
-        const bootstrapLayer = Layer.provide(
-          awsLayers,
-          Layer.succeed(ConfigProvider.ConfigProvider, provider),
+        const awsLayers = Layer.provideMerge(
+          Layer.mergeAll(
+            AWSRegion.fromEnvironment,
+            AWSCredentials.fromEnvironment,
+          ),
+          environment,
         );
-        if (destroy) {
-          yield* destroyBootstrapAws().pipe(
-            Effect.tap((result) =>
-              result.destroyed === 0
-                ? Console.log("✓ No bootstrap buckets found to destroy")
-                : Console.log(
-                    `✓ Destroyed ${result.destroyed} bootstrap bucket(s): ${result.bucketNames.join(", ")}`,
-                  ),
+
+        return yield* Effect.gen(function* () {
+          const provider = yield* loadConfigProvider(envFile);
+          const bootstrapLayer = Layer.provide(
+            awsLayers,
+            Layer.succeed(ConfigProvider.ConfigProvider, provider),
+          );
+          if (destroy) {
+            yield* destroyBootstrapAws().pipe(
+              Effect.tap((result) =>
+                result.destroyed === 0
+                  ? Console.log("✓ No bootstrap buckets found to destroy")
+                  : Console.log(
+                      `✓ Destroyed ${result.destroyed} bootstrap bucket(s): ${result.bucketNames.join(", ")}`,
+                    ),
+              ),
+              Effect.provide(bootstrapLayer),
+            );
+            return;
+          }
+          yield* bootstrapAws().pipe(
+            Effect.tap(({ bucketName, created }) =>
+              created
+                ? Console.log(`✓ Created assets bucket: ${bucketName}`)
+                : Console.log(`✓ Assets bucket already exists: ${bucketName}`),
             ),
             Effect.provide(bootstrapLayer),
           );
-          return;
-        }
-        yield* bootstrapAws().pipe(
-          Effect.tap(({ bucketName, created }) =>
-            created
-              ? Console.log(`✓ Created assets bucket: ${bucketName}`)
-              : Console.log(`✓ Assets bucket already exists: ${bucketName}`),
-          ),
-          Effect.provide(bootstrapLayer),
-        );
-      });
-    }).pipe(Effect.provide(logger));
-  })),
+        });
+      }).pipe(Effect.provide(logger));
+    }),
+  ),
 );

package/bin/commands/deploy.ts

@@ -149,7 +149,10 @@ export const destroyCommand = Command.make(
     yes,
     profile,
   },
-  instrumentCommand("destroy", stackSpanAttrs)((args) =>
+  instrumentCommand(
+    "destroy",
+    stackSpanAttrs,
+  )((args) =>
     execStack({
       ...args,
       destroy: true,
@@ -165,7 +168,10 @@ export const planCommand = Command.make(
     stage,
     profile,
   },
-  instrumentCommand("plan", stackSpanAttrs)((args) =>
+  instrumentCommand(
+    "plan",
+    stackSpanAttrs,
+  )((args) =>
     execStack({
       ...args,
       // plan is the same as deploy with dryRun always set to true

package/bin/commands/login.ts

@@ -45,67 +45,74 @@ export const loginCommand = Command.make(
   },
   instrumentCommand(
     "login",
-    (a: { main: string; stage: string; profile: string; configure: boolean }) => ({
+    (a: {
+      main: string;
+      stage: string;
+      profile: string;
+      configure: boolean;
+    }) => ({
       "alchemy.stage": a.stage,
       "alchemy.profile": a.profile,
       "alchemy.main": a.main,
       "alchemy.configure": a.configure,
     }),
-  )(Effect.fnUntraced(function* ({ main, stage, envFile, profile, configure }) {
-    const stackEffect = yield* importStack(main);
+  )(
+    Effect.fnUntraced(function* ({ main, stage, envFile, profile, configure }) {
+      const stackEffect = yield* importStack(main);
 
-    const authProviders: AuthProviders["Service"] = {};
+      const authProviders: AuthProviders["Service"] = {};
 
-    const services = Layer.mergeAll(
-      Layer.succeed(AuthProviders, authProviders),
-      ConfigProvider.layer(
-        withProfileOverride(yield* loadConfigProvider(envFile), profile),
-      ),
-      Logger.layer([fileLogger("out")]),
-      Layer.succeed(Stage, stage),
-      State.localState(),
-    );
-
-    yield* Effect.gen(function* () {
-      yield* Effect.catchCause(stackEffect, (cause) =>
-        Console.warn(
-          `Ignoring error while building stack for login (likely due to missing or broken credentials):\n${Cause.pretty(cause)}`,
+      const services = Layer.mergeAll(
+        Layer.succeed(AuthProviders, authProviders),
+        ConfigProvider.layer(
+          withProfileOverride(yield* loadConfigProvider(envFile), profile),
         ),
+        Logger.layer([fileLogger("out")]),
+        Layer.succeed(Stage, stage),
+        State.localState(),
       );
 
-      const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
-      const providers = Object.values(authProviders);
-
-      if (providers.length === 0) {
-        yield* Console.log(
-          "No AuthProviders registered. Make sure the stack's providers() layer includes AuthProviderLayer entries.",
+      yield* Effect.gen(function* () {
+        yield* Effect.catchCause(stackEffect, (cause) =>
+          Console.warn(
+            `Ignoring error while building stack for login (likely due to missing or broken credentials):\n${Cause.pretty(cause)}`,
+          ),
         );
-        return;
-      }
 
-      yield* Effect.forEach(
-        providers,
-        (provider) =>
-          Effect.gen(function* () {
-            const existing = yield* getProfile(profile);
-            const stored = existing?.[provider.name];
+        const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
+        const providers = Object.values(authProviders);
 
-            let cfg: { method: string };
-            if (configure || stored == null) {
-              cfg = yield* provider.configure(profile, { ci });
-              yield* setProfile(profile, {
-                ...existing,
-                [provider.name]: cfg,
-              });
-            } else {
-              cfg = stored;
-            }
+        if (providers.length === 0) {
+          yield* Console.log(
+            "No AuthProviders registered. Make sure the stack's providers() layer includes AuthProviderLayer entries.",
+          );
+          return;
+        }
 
-            yield* provider.login(profile, cfg);
-            yield* provider.prettyPrint(profile, cfg);
-          }),
-        { discard: true },
-      );
-    }).pipe(Effect.provide(services));
-  })),
+        yield* Effect.forEach(
+          providers,
+          (provider) =>
+            Effect.gen(function* () {
+              const existing = yield* getProfile(profile);
+              const stored = existing?.[provider.name];
+
+              let cfg: { method: string };
+              if (configure || stored == null) {
+                cfg = yield* provider.configure(profile, { ci });
+                yield* setProfile(profile, {
+                  ...existing,
+                  [provider.name]: cfg,
+                });
+              } else {
+                cfg = stored;
+              }
+
+              yield* provider.login(profile, cfg);
+              yield* provider.prettyPrint(profile, cfg);
+            }),
+          { discard: true },
+        );
+      }).pipe(Effect.provide(services));
+    }),
+  ),
 );

package/bin/commands/logs.ts

@@ -61,106 +61,108 @@ export const logsCommand = Command.make(
       "alchemy.main": a.main,
       "alchemy.limit": a.limit,
     }),
-  )(Effect.fnUntraced(function* ({
-    main,
-    stage,
-    envFile,
-    profile,
-    filter,
-    limit,
-    since,
-  }) {
-    const stackEffect = yield* importStack(main);
-
-    const services = Layer.mergeAll(
-      ConfigProvider.layer(
-        withProfileOverride(yield* loadConfigProvider(envFile), profile),
-      ),
-      Layer.succeed(AuthProviders, {}),
-      Layer.succeed(Stage, stage),
-      Logger.layer([fileLogger("out")]),
-      State.localState(),
-    );
-
-    const sinceDate = since ? parseSince(since) : undefined;
-
-    yield* Effect.gen(function* () {
-      const state = yield* State.State;
-      const stack = yield* stackEffect;
+  )(
+    Effect.fnUntraced(function* ({
+      main,
+      stage,
+      envFile,
+      profile,
+      filter,
+      limit,
+      since,
+    }) {
+      const stackEffect = yield* importStack(main);
+
+      const services = Layer.mergeAll(
+        ConfigProvider.layer(
+          withProfileOverride(yield* loadConfigProvider(envFile), profile),
+        ),
+        Layer.succeed(AuthProviders, {}),
+        Layer.succeed(Stage, stage),
+        Logger.layer([fileLogger("out")]),
+        State.localState(),
+      );
+
+      const sinceDate = since ? parseSince(since) : undefined;
 
       yield* Effect.gen(function* () {
-        const filterSet = parseResourceFilter(filter);
-        const availableIds = [
-          ...new Set(Object.values(stack.resources).map((r) => r.LogicalId)),
-        ].sort();
-
-        if (filterSet) {
-          for (const id of filterSet) {
-            if (!availableIds.includes(id)) {
-              return yield* Effect.die(
-                new Error(
-                  `Unknown resource '${id}' in --filter. Available: ${availableIds.join(", ") || "(none)"}`,
-                ),
-              );
+        const state = yield* State.State;
+        const stack = yield* stackEffect;
+
+        yield* Effect.gen(function* () {
+          const filterSet = parseResourceFilter(filter);
+          const availableIds = [
+            ...new Set(Object.values(stack.resources).map((r) => r.LogicalId)),
+          ].sort();
+
+          if (filterSet) {
+            for (const id of filterSet) {
+              if (!availableIds.includes(id)) {
+                return yield* Effect.die(
+                  new Error(
+                    `Unknown resource '${id}' in --filter. Available: ${availableIds.join(", ") || "(none)"}`,
+                  ),
+                );
+              }
             }
           }
-        }
 
-        const fqns = Object.keys(stack.resources);
-        const allLogs: { logicalId: string; lines: LogLine[] }[] = [];
+          const fqns = Object.keys(stack.resources);
+          const allLogs: { logicalId: string; lines: LogLine[] }[] = [];
 
-        for (const fqn of fqns) {
-          const resource = stack.resources[fqn]!;
-          if (filterSet && !filterSet.has(resource.LogicalId)) continue;
+          for (const fqn of fqns) {
+            const resource = stack.resources[fqn]!;
+            if (filterSet && !filterSet.has(resource.LogicalId)) continue;
 
-          const resourceState = yield* state.get({
-            stack: stack.name,
-            stage: stack.stage,
-            fqn,
-          });
-          if (!resourceState?.attr) continue;
+            const resourceState = yield* state.get({
+              stack: stack.name,
+              stage: stack.stage,
+              fqn,
+            });
+            if (!resourceState?.attr) continue;
 
-          const provider = yield* findProviderByType(resource.Type);
-          if (!provider.logs) continue;
+            const provider = yield* findProviderByType(resource.Type);
+            if (!provider.logs) continue;
 
-          const lines = yield* provider.logs({
-            id: resource.LogicalId,
-            instanceId: resourceState.instanceId,
-            props: resourceState.props as any,
-            output: resourceState.attr as any,
-            options: { limit, since: sinceDate },
-          });
+            const lines = yield* provider.logs({
+              id: resource.LogicalId,
+              instanceId: resourceState.instanceId,
+              props: resourceState.props as any,
+              output: resourceState.attr as any,
+              options: { limit, since: sinceDate },
+            });
 
-          allLogs.push({ logicalId: resource.LogicalId, lines });
-        }
+            allLogs.push({ logicalId: resource.LogicalId, lines });
+          }
 
-        if (allLogs.length === 0) {
-          if (filterSet) {
-            yield* Console.log(
-              "No resources with logs match --filter (deploy first, or selected resources may not expose logs).",
-            );
-          } else {
-            yield* Console.log(
-              "No resources with logs found. Deploy first, then run logs.",
-            );
+          if (allLogs.length === 0) {
+            if (filterSet) {
+              yield* Console.log(
+                "No resources with logs match --filter (deploy first, or selected resources may not expose logs).",
+              );
+            } else {
+              yield* Console.log(
+                "No resources with logs found. Deploy first, then run logs.",
+              );
+            }
+            return;
           }
-          return;
-        }
-
-        const merged = allLogs
-          .flatMap(({ logicalId, lines }, i) => {
-            const color = TAIL_COLORS[i % TAIL_COLORS.length]!;
-            return lines.map((line) => ({
-              ...line,
-              formatted: `${color}${formatLocalTimestamp(line.timestamp)} [${logicalId}]${TAIL_RESET} ${line.message}`,
-            }));
-          })
-          .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-
-        for (const entry of merged) {
-          yield* Console.log(entry.formatted);
-        }
-      }).pipe(Effect.provide(stack.services));
-    }).pipe(Effect.provide(services));
-  })),
+
+          const merged = allLogs
+            .flatMap(({ logicalId, lines }, i) => {
+              const color = TAIL_COLORS[i % TAIL_COLORS.length]!;
+              return lines.map((line) => ({
+                ...line,
+                formatted: `${color}${formatLocalTimestamp(line.timestamp)} [${logicalId}]${TAIL_RESET} ${line.message}`,
+              }));
+            })
+            .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+
+          for (const entry of merged) {
+            yield* Console.log(entry.formatted);
+          }
+        }).pipe(Effect.provide(stack.services));
+      }).pipe(Effect.provide(services));
+    }),
+  ),
 );

package/bin/commands/profile.ts

@@ -23,88 +23,92 @@ import { envFile, instrumentCommand, profile } from "./_shared.ts";
 const showCommand = Command.make(
   "show",
   { profile, envFile },
-  instrumentCommand(
-    "profile.show",
-    (a: { profile: string }) => ({ "alchemy.profile": a.profile }),
-  )(Effect.fnUntraced(function* ({ profile, envFile }) {
-    const stored = yield* getProfile(profile);
-    if (stored == null) {
-      const config = yield* readConfig;
-      const names = Object.keys(config.profiles);
-      yield* Console.log(`Profile '${profile}' not found.`);
-      if (names.length > 0) {
-        yield* Console.log(`Available profiles: ${names.sort().join(", ")}`);
-      } else {
-        yield* Console.log("No profiles configured. Run `alchemy login`.");
+  instrumentCommand("profile.show", (a: { profile: string }) => ({
+    "alchemy.profile": a.profile,
+  }))(
+    Effect.fnUntraced(function* ({ profile, envFile }) {
+      const stored = yield* getProfile(profile);
+      if (stored == null) {
+        const config = yield* readConfig;
+        const names = Object.keys(config.profiles);
+        yield* Console.log(`Profile '${profile}' not found.`);
+        if (names.length > 0) {
+          yield* Console.log(`Available profiles: ${names.sort().join(", ")}`);
+        } else {
+          yield* Console.log("No profiles configured. Run `alchemy login`.");
+        }
+        return;
       }
-      return;
-    }
 
-    yield* Console.log(`Profile: ${profile}`);
+      yield* Console.log(`Profile: ${profile}`);
 
-    const providerNames = Object.keys(stored).sort();
-    if (providerNames.length === 0) {
-      yield* Console.log("(no providers configured)");
-      return;
-    }
+      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(
-      authRegistry,
-      ConfigProvider.layer(
-        withProfileOverride(yield* loadConfigProvider(envFile), profile),
-      ),
-      Logger.layer([fileLogger("out")]),
-      // Building these layers triggers their AuthProviderLayer effect, which
-      // registers the provider into the shared `authProviders` registry.
-      Layer.provide(Layer.mergeAll(CloudflareAuth, AwsAuth), authRegistry),
-    );
+      const authProviders: AuthProviders["Service"] = {};
+      const authRegistry = Layer.succeed(AuthProviders, authProviders);
+      const services = Layer.mergeAll(
+        authRegistry,
+        ConfigProvider.layer(
+          withProfileOverride(yield* loadConfigProvider(envFile), profile),
+        ),
+        Logger.layer([fileLogger("out")]),
+        // Building these layers triggers their AuthProviderLayer effect, which
+        // registers the provider into the shared `authProviders` registry.
+        Layer.provide(Layer.mergeAll(CloudflareAuth, AwsAuth), 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)}`,
-            );
+      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;
           }
-          continue;
+          yield* provider.prettyPrint(profile, cfg);
         }
-        yield* provider.prettyPrint(profile, cfg);
-      }
-    }).pipe(Effect.provide(services));
-  })),
+      }).pipe(Effect.provide(services));
+    }),
+  ),
 );
 
 const clearCommand = Command.make(
   "clear",
   { profile },
-  instrumentCommand(
-    "profile.clear",
-    (a: { profile: string }) => ({ "alchemy.profile": a.profile }),
-  )(Effect.fnUntraced(function* ({ profile }) {
-    const removed = yield* deleteProfile(profile);
-    yield* deleteProfileCredentials(profile);
-    if (removed) {
-      yield* Console.log(
-        `Cleared profile '${profile}' and all its credentials.`,
-      );
-    } else {
-      yield* Console.log(
-        `Profile '${profile}' not found in profiles.json; removed any stray credentials directory.`,
-      );
-    }
-  })),
+  instrumentCommand("profile.clear", (a: { profile: string }) => ({
+    "alchemy.profile": a.profile,
+  }))(
+    Effect.fnUntraced(function* ({ profile }) {
+      const removed = yield* deleteProfile(profile);
+      yield* deleteProfileCredentials(profile);
+      if (removed) {
+        yield* Console.log(
+          `Cleared profile '${profile}' and all its credentials.`,
+        );
+      } else {
+        yield* Console.log(
+          `Profile '${profile}' not found in profiles.json; removed any stray credentials directory.`,
+        );
+      }
+    }),
+  ),
 );
 
 export const profileCommand = Command.make("profile", {}).pipe(