alchemy 2.0.0-beta.test-export-fix-4 → 2.0.0-cli-bundle-fix.1

package/bin/cli.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+// alchemy CLI launcher
+//
+// Resolves the alchemy CLI entrypoint via node module resolution and execs it
+// under whichever runtime the user invoked us with. The shebang forces this
+// launcher to run as node even when bun was the invoker, but bun forwards
+// signals about itself via env vars on every child it spawns:
+//
+//   - `npm_execpath`           → path to bun (set for `bun run <script>`)
+//   - `npm_config_user_agent`  → "bun/<version> ..." (set for `bun run`,
+//                                `bunx`, and direct bun-launched bins)
+//
+// Either signal is enough to know bun is the outer runtime.
+//
+// Dev vs published: when this launcher runs out of an alchemy checkout
+// (i.e. *not* from inside a `node_modules/` tree) and bun is available, we
+// run the .ts source directly so dev iteration is edit → reload, no rebuild.
+// The published tarball ships the .ts files as well (alchemy's `bun`/`worker`
+// exports point at .ts source), but consumers install into `node_modules/`,
+// so the path check sends them to the bundled `alchemy.js` regardless.
+//
+// foreground-child forwards stdio + signals and exits with the child's code,
+// so the launcher is transparent to the invoking shell / npm script.
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "pathe";
+import { foregroundChild } from "foreground-child";
+
+const require = createRequire(import.meta.url);
+
+const execpath = (process.env.npm_execpath ?? "").toLowerCase();
+const userAgent = (process.env.npm_config_user_agent ?? "").toLowerCase();
+const invokedByBun = execpath.includes("bun") || userAgent.startsWith("bun/");
+
+const jsEntry = require.resolve("alchemy/bin/alchemy.js");
+const binDir = path.dirname(jsEntry);
+const tsEntry = path.join(binDir, "alchemy.ts");
+
+// Treat any install-tree path as published; only a raw checkout uses .ts.
+const useTs = !(
+  jsEntry.includes("/node_modules/") || jsEntry.includes("\\node_modules\\")
+);
+
+// .ts only runs under bun. Force bun in dev even if node was the invoker.
+const runtime = useTs || invokedByBun ? "bun" : "node";
+
+const args = [];
+
+if (runtime === "bun" && useTs) {
+  // Pin bun's tsconfig to alchemy's, not whatever happens to be in the
+  // invoking workspace's cwd. Bun's default is `$cwd/tsconfig.json`, which
+  // means invoking `alchemy` from e.g. `examples/cloudflare-solidstart`
+  // would transpile alchemy's own .tsx files with that example's JSX
+  // settings (jsx: "preserve", jsxImportSource: "solid-js"), breaking the
+  // React files inside the alchemy CLI.
+  args.push(`--tsconfig-override=${path.join(binDir, "..", "tsconfig.json")}`);
+}
+
+args.push(useTs ? tsEntry : jsEntry, ...process.argv.slice(2));
+
+foregroundChild(runtime, args);

package/bin/commands/_shared.ts

@@ -0,0 +1,237 @@
+import * as Cause from "effect/Cause";
+import * as Config from "effect/Config";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as S from "effect/Schema";
+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 "../../src/Auth/AuthProvider.ts";
+import type * as Stack from "../../src/Stack.ts";
+import { PromptCancelled } from "../../src/Util/Clank.ts";
+
+export const USER = Config.string("USER").pipe(
+  Config.orElse(() => Config.string("USERNAME")),
+  Config.withDefault("unknown"),
+);
+
+export const STAGE = Config.string("stage").pipe(
+  Config.option,
+  (a) => a.asEffect(),
+  Effect.map(Option.getOrUndefined),
+);
+
+/**
+ * `true` if `e` is a {@link PromptCancelled}, or an {@link AuthError} whose
+ * `cause` chain bottoms out in one. Schema-tagged errors don't always
+ * survive `instanceof` across module boundaries, so we also accept any
+ * object whose `_tag` matches.
+ */
+const isPromptCancellation = (e: unknown): boolean => {
+  for (let cur: unknown = e, i = 0; cur != null && i < 16; i++) {
+    if (cur instanceof PromptCancelled) return true;
+    if (
+      typeof cur === "object" &&
+      (cur as { _tag?: unknown })._tag === "PromptCancelled"
+    ) {
+      return true;
+    }
+    if (
+      cur instanceof AuthError ||
+      (typeof cur === "object" &&
+        (cur as { _tag?: unknown })._tag === "AuthError")
+    ) {
+      cur = (cur as { cause?: unknown }).cause;
+      continue;
+    }
+    return false;
+  }
+  return false;
+};
+
+/**
+ * Catches user cancellations (Ctrl+C inside a prompt, surfaced as
+ * {@link PromptCancelled} or wrapped in an {@link AuthError}) and exits
+ * the CLI cleanly with a friendly message instead of dumping a stack
+ * trace.
+ */
+export const handleCancellation = <A, E, R>(self: Effect.Effect<A, E, R>) =>
+  self.pipe(
+    Effect.catchCause((cause) => {
+      const cancelled = cause.reasons.some((r) => {
+        if (Cause.isFailReason(r)) return isPromptCancellation(r.error);
+        if (Cause.isDieReason(r)) return isPromptCancellation(r.defect);
+        return false;
+      });
+      return cancelled
+        ? Console.log("\nCancelled.")
+        : (Effect.failCause(cause) as Effect.Effect<never, E, never>);
+    }),
+    // A bare fiber interrupt (Ctrl+C while not inside a prompt) shouldn't
+    // dump a stack trace either.
+    Effect.onInterrupt(() => Console.log("\nInterrupted.")),
+  );
+
+export 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.catch(() =>
+          Effect.fail(
+            new CliError.MissingOption({
+              option: "stage",
+            }),
+          ),
+        ),
+        Effect.flatMap((s) =>
+          s === undefined
+            ? USER.asEffect().pipe(
+                Effect.map((user) => `dev_${user}`),
+                Effect.catch(() => Effect.succeed("unknown")),
+              )
+            : Effect.succeed(s),
+        ),
+      );
+    }),
+  ),
+);
+
+export const envFile = Flag.file("env-file").pipe(
+  Flag.optional,
+  Flag.withDescription(
+    "File to load environment variables from, defaults to .env",
+  ),
+);
+
+export const dryRun = Flag.boolean("dry-run").pipe(
+  Flag.withDescription("Dry run the deployment, do not actually deploy"),
+  Flag.withDefault(false),
+);
+
+export const yes = Flag.boolean("yes").pipe(
+  Flag.withDescription("Yes to all prompts"),
+  Flag.withDefault(false),
+);
+
+export const force = Flag.boolean("force").pipe(
+  Flag.withDescription(
+    "Force updates for resources that would otherwise no-op",
+  ),
+  Flag.withDefault(false),
+);
+
+export const main = Argument.file("main", {
+  mustExist: true,
+}).pipe(
+  Argument.withDescription("Main file to deploy, defaults to alchemy.run.ts"),
+  Argument.withDefault("alchemy.run.ts"),
+);
+
+export const profile = Flag.string("profile").pipe(
+  Flag.withDescription(
+    "Auth profile to use (~/.alchemy/profiles.json). Defaults to 'default' or $ALCHEMY_PROFILE.",
+  ),
+  Flag.optional,
+  Flag.map(Option.getOrElse(() => "default")),
+);
+
+export 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),
+);
+
+export 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
+];
+export const TAIL_RESET = "\x1b[0m";
+
+export 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}`;
+};
+
+export 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);
+};
+
+export 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;
+};
+
+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 stackEffect = module.default as ReturnType<
+    ReturnType<typeof Stack.make>
+  >;
+  if (!Effect.isEffect(stackEffect)) {
+    return yield* Effect.die(
+      new Error(
+        `Main file '${main}' must export a default stack definition (export default Alchemy.Stack({...}))`,
+      ),
+    );
+  }
+  return stackEffect;
+});

package/bin/commands/bootstrap.ts

@@ -0,0 +1,117 @@
+import * as Auth from "@distilled.cloud/aws/Auth";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import type { FileSystem } from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import { Path } from "effect/Path";
+import * as Command from "effect/unstable/cli/Command";
+import * as Flag from "effect/unstable/cli/Flag";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
+
+import {
+  bootstrap as bootstrapAws,
+  destroyBootstrap as destroyBootstrapAws,
+} from "../../src/AWS/Bootstrap.ts";
+import * as AWSCredentials from "../../src/AWS/Credentials.ts";
+import * as AWSEnvironment from "../../src/AWS/Environment.ts";
+import * as AWSRegion from "../../src/AWS/Region.ts";
+import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
+import { fileLogger } from "../../src/Util/FileLogger.ts";
+
+import { envFile } from "./_shared.ts";
+
+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),
+);
+
+export const bootstrapCommand = Command.make(
+  "bootstrap",
+  {
+    envFile,
+    profile: awsProfile,
+    region: awsRegion,
+    destroy: bootstrapDestroy,
+  },
+  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,
+      });
+
+      const awsLayers = Layer.provideMerge(
+        Layer.mergeAll(
+          AWSRegion.fromEnvironment,
+          AWSCredentials.fromEnvironment,
+        ),
+        environment,
+      );
+
+      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(logger));
+  }),
+);

package/bin/commands/deploy.ts

@@ -0,0 +1,146 @@
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import * as Command from "effect/unstable/cli/Command";
+
+import { apply } from "../../src/Apply.ts";
+import { ArtifactStore, createArtifactStore } from "../../src/Artifacts.ts";
+import { AuthProviders } from "../../src/Auth/AuthProvider.ts";
+import { withProfileOverride } from "../../src/Auth/Profile.ts";
+import * as CLI from "../../src/Cli/index.ts";
+import * as Plan from "../../src/Plan.ts";
+import { Stage } from "../../src/Stage.ts";
+import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
+import { fileLogger } from "../../src/Util/FileLogger.ts";
+
+import {
+  dryRun as dryRunFlag,
+  envFile,
+  force,
+  importStack,
+  main,
+  profile,
+  stage,
+  yes,
+} from "./_shared.ts";
+
+const execStack = Effect.fn(function* ({
+  main,
+  stage,
+  envFile,
+  profile,
+  dryRun = false,
+  force = false,
+  yes = false,
+  destroy = false,
+}: {
+  main: string;
+  stage: string;
+  envFile: Option.Option<string>;
+  profile: string;
+  dryRun?: boolean;
+  force?: boolean;
+  yes?: boolean;
+  destroy?: boolean;
+}) {
+  const stackEffect = yield* importStack(main);
+
+  const services = Layer.mergeAll(
+    Layer.succeed(ArtifactStore, createArtifactStore()),
+    Layer.succeed(
+      AuthProviders,
+      yield* Effect.serviceOption(AuthProviders).pipe(
+        Effect.map(Option.getOrElse(() => ({}))),
+      ),
+    ),
+    ConfigProvider.layer(
+      withProfileOverride(yield* loadConfigProvider(envFile), profile),
+    ),
+    Logger.layer([fileLogger("out")]),
+    Layer.succeed(Stage, stage),
+  );
+
+  yield* Effect.gen(function* () {
+    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,
+        { force },
+      );
+      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);
+      }
+    }).pipe(Effect.provide(stack.services));
+  }).pipe(Effect.provide(services));
+});
+
+export const deployCommand = Command.make(
+  "deploy",
+  {
+    dryRun: dryRunFlag,
+    force,
+    main,
+    envFile,
+    stage,
+    yes,
+    profile,
+  },
+  execStack,
+);
+
+export const destroyCommand = Command.make(
+  "destroy",
+  {
+    dryRun: dryRunFlag,
+    main,
+    envFile,
+    stage,
+    yes,
+    profile,
+  },
+  (args) =>
+    execStack({
+      ...args,
+      destroy: true,
+    }),
+);
+
+export const planCommand = Command.make(
+  "plan",
+  {
+    main,
+    envFile,
+    stage,
+    profile,
+  },
+  (args) =>
+    execStack({
+      ...args,
+      // plan is the same as deploy with dryRun always set to true
+      dryRun: true,
+    }),
+);

package/bin/commands/login.ts

@@ -0,0 +1,93 @@
+import * as Config from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { AuthProviders } from "../../src/Auth/AuthProvider.ts";
+import {
+  getProfile,
+  setProfile,
+  withProfileOverride,
+} from "../../src/Auth/Profile.ts";
+import { Stage } from "../../src/Stage.ts";
+import * as State from "../../src/State/index.ts";
+import { loadConfigProvider } from "../../src/Util/ConfigProvider.ts";
+import { fileLogger } from "../../src/Util/FileLogger.ts";
+
+import { envFile, importStack, main, profile, stage } from "./_shared.ts";
+
+const loginConfigure = Flag.boolean("configure").pipe(
+  Flag.withDescription(
+    "Run the provider's interactive configure step before logging in",
+  ),
+  Flag.withDefault(false),
+);
+
+export const loginCommand = Command.make(
+  "login",
+  {
+    main,
+    envFile,
+    stage,
+    profile,
+    configure: loginConfigure,
+  },
+  Effect.fnUntraced(function* ({ main, stage, envFile, profile, configure }) {
+    const stackEffect = yield* importStack(main);
+
+    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* () {
+      // Build the stack — this triggers each provider's AuthProviderLayer,
+      // which registers itself into the shared `authProviders` registry.
+      yield* stackEffect;
+
+      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.",
+        );
+        return;
+      }
+
+      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));
+  }),
+);