alchemy-effect 0.6.0 → 0.6.3

package/bin/alchemy-effect.ts

@@ -1,26 +1,37 @@
-import { Command, Options, Args } from "@effect/cli";
-import * as ValidationError from "@effect/cli/ValidationError";
-import * as HelpDoc from "@effect/cli/HelpDoc";
+import * as Auth from "@distilled.cloud/aws/Auth";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
-import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import * as PlatformConfigProvider from "@effect/platform/PlatformConfigProvider";
-import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
-import { Path } from "@effect/platform/Path";
-import * as Logger from "effect/Logger";
+import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
-import * as Config from "effect/Config";
-import * as Option from "effect/Option";
+import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
-import { asEffect } from "../src/util.ts";
-import packageJson from "../package.json";
-import * as State from "../src/state.ts";
-import { applyPlan } from "../src/apply.ts";
-import { plan } from "../src/plan.ts";
-import { dotAlchemy } from "../src/dot-alchemy.ts";
-import * as App from "../src/app.ts";
-import type { Stack } from "../src/stack.ts";
-import * as CLI from "../src/cli/index.ts";
-import { Resource } from "../src/resource.ts";
+import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import { Path } from "effect/Path";
+import * as S from "effect/Schema";
+import * as Stream from "effect/Stream";
+import { Argument, Command, Flag } from "effect/unstable/cli";
+import * as CliError from "effect/unstable/cli/CliError";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+
+import packageJson from "../package.json" with { type: "json" };
+import { apply } from "../src/Apply.ts";
+import * as AWSAccount from "../src/AWS/Account.ts";
+import {
+  bootstrap as bootstrapAws,
+  destroyBootstrap as destroyBootstrapAws,
+} from "../src/AWS/Bootstrap.ts";
+import * as AWSCredentials from "../src/AWS/Credentials.ts";
+import * as AWSRegion from "../src/AWS/Region.ts";
+import * as CLI from "../src/Cli/index.ts";
+import { DotAlchemy, dotAlchemy } from "../src/Config.ts";
+import * as Plan from "../src/Plan.ts";
+import { getProviderByType, type LogLine } from "../src/Provider.ts";
+import * as Stack from "../src/Stack.ts";
+import { Stage } from "../src/Stage.ts";
+import * as State from "../src/State/index.ts";
 
 const USER = Config.string("USER").pipe(
   Config.orElse(() => Config.string("USERNAME")),
@@ -29,70 +40,101 @@ const USER = Config.string("USER").pipe(
 
 const STAGE = Config.string("stage").pipe(
   Config.option,
+  (a) => a.asEffect(),
   Effect.map(Option.getOrUndefined),
 );
 
-const stage = Options.text("stage").pipe(
-  Options.withDescription("Stage to deploy to, defaults to dev_${USER}"),
-  Options.optional,
-  Options.map(Option.getOrUndefined),
-  Options.mapEffect(
+const stage = Flag.string("stage").pipe(
+  Flag.withSchema(S.String.check(S.isPattern(/^[a-z0-9]+([-_a-z0-9]+)*$/gi))),
+  Flag.withDescription("Stage to deploy to, defaults to dev_${USER}"),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+  Flag.mapEffect(
     Effect.fn(function* (stage) {
       if (stage) {
         return stage;
       }
       return yield* STAGE.pipe(
-        Effect.catchAll((err) =>
-          Effect.fail(ValidationError.invalidValue(HelpDoc.p(err.message))),
+        Effect.catch(() =>
+          Effect.fail(
+            new CliError.MissingOption({
+              option: "stage",
+            }),
+          ),
         ),
         Effect.flatMap((s) =>
           s === undefined
-            ? USER.pipe(
+            ? USER.asEffect().pipe(
                 Effect.map((user) => `dev_${user}`),
-                Effect.catchAll(() => Effect.succeed("unknown")),
+                Effect.catch(() => Effect.succeed("unknown")),
               )
             : Effect.succeed(s),
         ),
       );
     }),
   ),
-  Options.mapEffect((stage) => {
-    const regex = /^[a-z0-9]+([-_a-z0-9]+)*$/gi;
-    return regex.test(stage)
-      ? Effect.succeed(stage)
-      : Effect.fail(
-          ValidationError.invalidValue(
-            HelpDoc.p(
-              `Stage '${stage}' is invalid. Must match the regex ${regex.source} (alphanumeric characters, hyphens and dashes).`,
-            ),
-          ),
-        );
-  }),
 );
 
-const envFile = Options.file("env-file").pipe(
-  Options.optional,
-  Options.withDescription(
+const envFile = Flag.file("env-file").pipe(
+  Flag.optional,
+  Flag.withDescription(
     "File to load environment variables from, defaults to .env",
   ),
 );
 
-const dryRun = Options.boolean("dry-run").pipe(
-  Options.withDescription("Dry run the deployment, do not actually deploy"),
-  Options.withDefault(false),
+const dryRun = Flag.boolean("dry-run").pipe(
+  Flag.withDescription("Dry run the deployment, do not actually deploy"),
+  Flag.withDefault(false),
 );
 
-const yes = Options.boolean("yes").pipe(
-  Options.withDescription("Yes to all prompts"),
-  Options.withDefault(false),
+const yes = Flag.boolean("yes").pipe(
+  Flag.withDescription("Yes to all prompts"),
+  Flag.withDefault(false),
 );
 
-const main = Args.file({
-  name: "main",
-  exists: "yes",
+const fileLogger = Effect.fnUntraced(function* (
+  ...segments: ReadonlyArray<string>
+) {
+  const dotAlchemy = yield* DotAlchemy;
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path;
+  const logFile = path.join(dotAlchemy, "log", ...segments);
+
+  yield* fs.makeDirectory(path.dirname(logFile), { recursive: true });
+
+  return yield* Logger.formatLogFmt.pipe(
+    Logger.toFile(logFile, {
+      flag: "a",
+    }),
+  );
+});
+
+const loadConfigProvider = (envFile: Option.Option<string>) => {
+  if (Option.isSome(envFile)) {
+    return ConfigProvider.fromDotEnv({ path: envFile.value }).pipe(
+      Effect.map((dotEnv) =>
+        ConfigProvider.orElse(dotEnv, ConfigProvider.fromEnv()),
+      ),
+    );
+  }
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const exists = yield* fs.exists(".env");
+    if (!exists) {
+      return ConfigProvider.fromEnv();
+    }
+    return ConfigProvider.orElse(
+      yield* ConfigProvider.fromDotEnv({ path: ".env" }),
+      ConfigProvider.fromEnv(),
+    );
+  });
+};
+
+const main = Argument.file("main", {
+  mustExist: true,
 }).pipe(
-  Args.withDescription("Main file to deploy, defaults to alchemy.run.ts"),
-  Args.withDefault("alchemy.run.ts"),
+  Argument.withDescription("Main file to deploy, defaults to alchemy.run.ts"),
+  Argument.withDefault("alchemy.run.ts"),
 );
 
 const deployCommand = Command.make(
@@ -104,11 +146,7 @@ const deployCommand = Command.make(
     stage,
     yes,
   },
-  (args) =>
-    execStack({
-      ...args,
-      select: (stack) => stack.resources,
-    }),
+  (args) => execStack(args),
 );
 
 const destroyCommand = Command.make(
@@ -118,12 +156,12 @@ const destroyCommand = Command.make(
     main,
     envFile,
     stage,
+    yes,
   },
   (args) =>
     execStack({
       ...args,
-      // destroy is just a plan with 0 resources
-      select: () => [],
+      destroy: true,
     }),
 );
 
@@ -139,7 +177,6 @@ const planCommand = Command.make(
       ...args,
       // plan is the same as deploy with dryRun always set to true
       dryRun: true,
-      select: (stack) => stack.resources,
     }),
 );
 
@@ -149,28 +186,23 @@ const execStack = Effect.fn(function* ({
   envFile,
   dryRun = false,
   yes = false,
-  select,
+  destroy = false,
 }: {
   main: string;
   stage: string;
   envFile: Option.Option<string>;
   dryRun?: boolean;
   yes?: boolean;
-  select: (stack: Stack<string, any, never, never, never, never>) => Resource[];
+  destroy?: boolean;
 }) {
   const path = yield* Path;
   const module = yield* Effect.promise(
     () => import(path.resolve(process.cwd(), main)),
   );
-  const stack = module.default as Stack<
-    string,
-    any,
-    never,
-    never,
-    never,
-    never
+  const stackEffect = module.default as ReturnType<
+    ReturnType<typeof Stack.make>
   >;
-  if (!stack) {
+  if (!stackEffect) {
     return yield* Effect.die(
       new Error(
         `Main file '${main}' must export a default stack definition (export default defineStack({...}))`,
@@ -178,89 +210,571 @@ const execStack = Effect.fn(function* ({
     );
   }
 
-  const stackName = stack.name;
-
-  const configProvider = Option.isSome(envFile)
-    ? ConfigProvider.orElse(
-        yield* PlatformConfigProvider.fromDotEnv(envFile.value),
-        ConfigProvider.fromEnv,
-      )
-    : ConfigProvider.fromEnv();
-
-  const stageConfig = yield* asEffect(stack.stages.config(stage)).pipe(
-    Effect.provide(stack.layers ?? Layer.empty),
-    Effect.withConfigProvider(configProvider),
-  );
+  const configProvider = yield* loadConfigProvider(envFile);
 
   // TODO(sam): implement local and watch
-  const platform = Layer.mergeAll(
-    NodeContext.layer,
-    FetchHttpClient.layer,
-    Logger.pretty,
-  );
+  const platform = Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer);
+
+  const rootLogger = Logger.layer([fileLogger("out")]);
 
   // override alchemy state store, CLI/reporting and dotAlchemy
   const alchemy = Layer.mergeAll(
-    stack.state ?? State.localFs,
-    stack.cli ?? CLI.inkCLI(),
+    // TODO(sam): support overriding these
+    State.LocalState,
+    CLI.inkCLI(),
     // optional
-    dotAlchemy,
-  );
-
-  const layers = Layer.provideMerge(
-    Layer.provideMerge(stack.providers, alchemy),
-    Layer.mergeAll(
-      platform,
-      App.make({
-        name: stackName,
-        stage,
-        config: stageConfig,
-      }),
-    ),
+    Layer.provideMerge(rootLogger, dotAlchemy),
   );
 
   yield* Effect.gen(function* () {
-    const cli = yield* CLI.CLI;
-    const resources = select(stack);
-    const updatePlan = yield* plan(...resources);
-    if (dryRun) {
-      yield* cli.displayPlan(updatePlan);
-    } else {
-      if (!yes) {
-        const approved = yield* cli.approvePlan(updatePlan);
-        if (!approved) {
-          return;
+    const cli = yield* CLI.Cli;
+    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: {},
+              output: {},
+            }
+          : stack,
+      );
+      if (dryRun) {
+        yield* cli.displayPlan(updatePlan);
+      } else {
+        if (!yes) {
+          const approved = yield* cli.approvePlan(updatePlan);
+          if (!approved) {
+            return;
+          }
         }
+        const outputs = yield* apply(updatePlan);
+
+        yield* Console.log(outputs);
       }
-      const outputs = yield* applyPlan(updatePlan);
-      if (outputs && stack.tap) {
-        yield* stack
-          .tap(outputs)
-          .pipe(Effect.provide(stack.layers ?? Layer.empty));
-      }
-    }
+    }).pipe(
+      Effect.provide(stack.services),
+      // Effect.provide(Logger.layer([fileLogger("stacks", stack.name, stage)])),
+    );
   }).pipe(
-    Effect.provide(layers),
-    Effect.withConfigProvider(configProvider),
+    Effect.provide(
+      Layer.provideMerge(
+        alchemy,
+        Layer.mergeAll(platform, Layer.succeed(Stage, stage)),
+      ),
+    ),
+    Effect.provideService(ConfigProvider.ConfigProvider, configProvider),
   ) as Effect.Effect<void, any, never>;
   // TODO(sam): figure out why we need to cast to remove the Provider<never> requirement
   // Effect.Effect<void, any, Provider<never>>;
 });
 
+const resourceFilter = Flag.string("filter").pipe(
+  Flag.withDescription(
+    "Comma-separated logical resource IDs (e.g. Api,Sandbox). Only those resources are included.",
+  ),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+);
+
+const tailCommand = Command.make(
+  "tail",
+  {
+    main,
+    envFile,
+    stage,
+    filter: resourceFilter,
+  },
+  Effect.fnUntraced(function* ({
+    main,
+    stage,
+    envFile,
+    filter,
+  }: {
+    main: string;
+    stage: string;
+    envFile: Option.Option<string>;
+    filter: string | undefined;
+  }) {
+    const path = yield* Path;
+    const module = yield* Effect.promise(
+      () => import(path.resolve(process.cwd(), main)),
+    );
+    const stackEffect = module.default as ReturnType<
+      ReturnType<typeof Stack.make>
+    >;
+    if (!stackEffect) {
+      return yield* Effect.die(
+        new Error(
+          `Main file '${main}' must export a default stack definition (export default defineStack({...}))`,
+        ),
+      );
+    }
+
+    const configProvider = yield* loadConfigProvider(envFile);
+
+    const platform = Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer);
+
+    const rootLogger = Logger.layer([fileLogger("out")]);
+
+    const alchemy = Layer.mergeAll(
+      State.LocalState,
+      Layer.provideMerge(rootLogger, dotAlchemy),
+    );
+
+    yield* Effect.gen(function* () {
+      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 tailable: {
+          logicalId: string;
+          stream: Stream.Stream<LogLine, any, any>;
+        }[] = [];
+
+        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 provider = yield* getProviderByType(resource.Type);
+          if (!provider.tail) continue;
+
+          tailable.push({
+            logicalId: resource.LogicalId,
+            stream: provider.tail({
+              id: resource.LogicalId,
+              instanceId: resourceState.instanceId,
+              props: resourceState.props as any,
+              output: resourceState.attr as any,
+            }),
+          });
+        }
+
+        if (tailable.length === 0) {
+          if (filterSet) {
+            yield* Console.log(
+              "No tailable resources match --filter (deploy first, or selected resources may not support tail).",
+            );
+          } else {
+            yield* Console.log(
+              "No tailable resources found. Deploy first, then run tail.",
+            );
+          }
+          return;
+        }
+
+        yield* Console.log(
+          `Tailing: ${tailable.map((t) => t.logicalId).join(", ")}`,
+        );
+
+        const taggedStreams = tailable.map(({ logicalId, stream }, i) => {
+          const color = TAIL_COLORS[i % TAIL_COLORS.length]!;
+          return stream.pipe(
+            Stream.map(({ timestamp, message }) => {
+              const ts = formatLocalTimestamp(timestamp);
+              return `${color}${ts} [${logicalId}]${TAIL_RESET} ${message}`;
+            }),
+          );
+        });
+
+        yield* Stream.mergeAll(taggedStreams, {
+          concurrency: "unbounded",
+        }).pipe(Stream.runForEach((line) => Console.log(line)));
+      }).pipe(Effect.provide(stack.services));
+    }).pipe(
+      Effect.provide(
+        Layer.provideMerge(
+          alchemy,
+          Layer.mergeAll(platform, Layer.succeed(Stage, stage)),
+        ),
+      ),
+      Effect.provideService(ConfigProvider.ConfigProvider, configProvider),
+      Effect.scoped,
+    ) as Effect.Effect<void, any, never>;
+  }),
+);
+
+const awsProfile = Flag.string("profile").pipe(
+  Flag.withDescription("AWS profile to use for credentials"),
+  Flag.optional,
+  Flag.map(Option.getOrElse(() => "default")),
+);
+
+const awsRegion = Flag.string("region").pipe(
+  Flag.withDescription(
+    "AWS region to bootstrap (defaults to AWS_REGION env var)",
+  ),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+);
+
+const bootstrapDestroy = Flag.boolean("destroy").pipe(
+  Flag.withDescription("Destroy all bootstrap buckets in the selected region"),
+  Flag.withDefault(false),
+);
+
+const bootstrapCommand = Command.make(
+  "bootstrap",
+  {
+    envFile,
+    profile: awsProfile,
+    region: awsRegion,
+    destroy: bootstrapDestroy,
+  },
+  Effect.fnUntraced(function* ({ envFile, profile, region, destroy }) {
+    const platform = Layer.mergeAll(
+      NodeServices.layer,
+      FetchHttpClient.layer,
+      Layer.provideMerge(
+        Logger.layer([fileLogger("bootstrap.txt")]),
+        dotAlchemy,
+      ),
+    );
+
+    return yield* Effect.gen(function* () {
+      const ssoProfile = yield* Auth.loadProfile(profile);
+
+      const credentials = yield* Auth.loadProfileCredentials(profile);
+
+      const awsLayers = Layer.mergeAll(
+        Layer.succeed(AWSAccount.Account, profile),
+        Layer.succeed(
+          AWSRegion.Region,
+          region ?? ssoProfile.region ?? "us-east-1",
+        ),
+        Layer.succeed(AWSCredentials.Credentials, Effect.succeed(credentials)),
+      );
+
+      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),
+        );
+      });
+    }).pipe(Effect.provide(platform)) as Effect.Effect<void, any, never>;
+  }),
+);
+
+const devCommand = Command.make(
+  "dev",
+  {
+    main,
+    envFile,
+    stage,
+  },
+  ({ envFile, main, stage }) =>
+    Effect.gen(function* () {
+      const cmd = ChildProcess.make("bun", ["--hot", main], {
+        env: {
+          ALCHEMY_PHASE: "dev",
+        },
+      });
+
+      const proc = yield* cmd;
+
+      proc.stdout;
+      proc.stderr;
+      proc.all;
+    }),
+);
+
+const TAIL_COLORS = [
+  "\x1b[36m", // cyan
+  "\x1b[35m", // magenta
+  "\x1b[33m", // yellow
+  "\x1b[32m", // green
+  "\x1b[34m", // blue
+  "\x1b[91m", // bright red
+  "\x1b[96m", // bright cyan
+  "\x1b[95m", // bright magenta
+  "\x1b[93m", // bright yellow
+  "\x1b[92m", // bright green
+];
+const TAIL_RESET = "\x1b[0m";
+
+const formatLocalTimestamp = (date: Date): string => {
+  const y = date.getFullYear();
+  const mo = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const mi = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  const tz =
+    new Intl.DateTimeFormat("en-US", { timeZoneName: "short" })
+      .formatToParts(date)
+      .find((p) => p.type === "timeZoneName")?.value ?? "";
+  return `${y}-${mo}-${d} ${h}:${mi}:${s}.${ms} ${tz}`;
+};
+
+const logsLimit = Flag.integer("limit").pipe(
+  Flag.withDescription("Number of log entries to fetch"),
+  Flag.withDefault(100),
+);
+
+const logsSince = Flag.string("since").pipe(
+  Flag.withDescription(
+    "Fetch logs since this time (e.g. '1h', '30m', '2024-01-01T00:00:00Z')",
+  ),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+);
+
+const logsCommand = Command.make(
+  "logs",
+  {
+    main,
+    envFile,
+    stage,
+    filter: resourceFilter,
+    limit: logsLimit,
+    since: logsSince,
+  },
+  Effect.fnUntraced(function* ({
+    main,
+    stage,
+    envFile,
+    filter,
+    limit,
+    since,
+  }: {
+    main: string;
+    stage: string;
+    envFile: Option.Option<string>;
+    filter: string | undefined;
+    limit: number;
+    since: string | undefined;
+  }) {
+    const path = yield* Path;
+    const module = yield* Effect.promise(
+      () => import(path.resolve(process.cwd(), main)),
+    );
+    const stackEffect = module.default as ReturnType<
+      ReturnType<typeof Stack.make>
+    >;
+    if (!stackEffect) {
+      return yield* Effect.die(
+        new Error(
+          `Main file '${main}' must export a default stack definition (export default defineStack({...}))`,
+        ),
+      );
+    }
+
+    const configProvider = yield* loadConfigProvider(envFile);
+
+    const platform = Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer);
+
+    const rootLogger = Logger.layer([fileLogger("out")]);
+
+    const alchemy = Layer.mergeAll(
+      State.LocalState,
+      Layer.provideMerge(rootLogger, dotAlchemy),
+    );
+
+    const sinceDate = since ? parseSince(since) : undefined;
+
+    yield* Effect.gen(function* () {
+      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[] }[] = [];
+
+        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 provider = yield* getProviderByType(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 },
+          });
+
+          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.",
+            );
+          }
+          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(
+        Layer.provideMerge(
+          alchemy,
+          Layer.mergeAll(platform, Layer.succeed(Stage, stage)),
+        ),
+      ),
+      Effect.provideService(ConfigProvider.ConfigProvider, configProvider),
+      Effect.scoped,
+    ) as Effect.Effect<void, any, never>;
+  }),
+);
+
+const parseResourceFilter = (
+  filter: string | undefined,
+): ReadonlySet<string> | undefined => {
+  if (filter === undefined) return undefined;
+  const ids = filter
+    .split(",")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+  if (ids.length === 0) return undefined;
+  return new Set(ids);
+};
+
+const parseSince = (value: string): Date => {
+  const match = value.match(/^(\d+)([smhd])$/);
+  if (match) {
+    const num = parseInt(match[1]!, 10);
+    const unit = match[2]!;
+    const ms =
+      unit === "s"
+        ? num * 1000
+        : unit === "m"
+          ? num * 60_000
+          : unit === "h"
+            ? num * 3_600_000
+            : num * 86_400_000;
+    return new Date(Date.now() - ms);
+  }
+  const parsed = new Date(value);
+  if (isNaN(parsed.getTime())) {
+    throw new Error(
+      `Invalid --since value: '${value}'. Use a duration (e.g. '1h', '30m') or ISO date.`,
+    );
+  }
+  return parsed;
+};
+
 const root = Command.make("alchemy-effect", {}).pipe(
-  Command.withSubcommands([deployCommand, destroyCommand, planCommand]),
+  Command.withSubcommands([
+    bootstrapCommand,
+    deployCommand,
+    destroyCommand,
+    planCommand,
+    tailCommand,
+    logsCommand,
+  ]),
 );
 
 // Set up the CLI application
 const cli = Command.run(root, {
-  name: "Alchemy Effect CLI",
+  // name: "Alchemy Effect CLI",
   version: packageJson.version,
 });
 
 // Prepare and run the CLI application
-cli(process.argv).pipe(
+cli.pipe(
   // $USER and $STAGE are set by the environment
-  Effect.withConfigProvider(ConfigProvider.fromEnv()),
-  Effect.provide(NodeContext.layer),
+  Effect.provideService(
+    ConfigProvider.ConfigProvider,
+    ConfigProvider.fromEnv(),
+  ),
+  Effect.provide(NodeServices.layer),
+  Effect.scoped,
   NodeRuntime.runMain,
 );