alchemy 2.0.0-beta.2 → 2.0.0-beta.21

package/bin/alchemy.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+# Auto-generated by scripts/hoist-alchemy-bin.ts. Do not edit.
+# Dev-only shim: runs alchemy.ts under bun, falls back to alchemy.js under node.
+RUNTIME=node
+case "$npm_execpath" in
+  *bun*) RUNTIME=bun ;;
+esac
+if [ "$RUNTIME" = "node" ] && command -v bun >/dev/null 2>&1; then
+  RUNTIME=bun
+fi
+if [ "$RUNTIME" = "bun" ]; then
+  exec bun "/Users/samgoodwin/workspaces/alchemy-effect/packages/alchemy/bin/alchemy.ts" "$@"
+else
+  exec node "/Users/samgoodwin/workspaces/alchemy-effect/packages/alchemy/bin/alchemy.js" "$@"
+fi

package/bin/alchemy.ts

@@ -0,0 +1,59 @@
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Command from "effect/unstable/cli/Command";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+
+import packageJson from "../package.json" with { type: "json" };
+import { AlchemyContextLive } from "../src/AlchemyContext.ts";
+import { inkCLI } from "../src/Cli/InkCLI.tsx";
+import { TelemetryLive } from "../src/Telemetry/Layer.ts";
+import { PlatformServices, runMain } from "../src/Util/PlatformServices.ts";
+
+import { handleCancellation } from "./commands/_shared.ts";
+import { bootstrapCommand } from "./commands/bootstrap.ts";
+import {
+  deployCommand,
+  destroyCommand,
+  planCommand,
+} from "./commands/deploy.ts";
+import { loginCommand } from "./commands/login.ts";
+import { logsCommand } from "./commands/logs.ts";
+import { profileCommand } from "./commands/profile.ts";
+import { stateCommand } from "./commands/state.ts";
+import { tailCommand } from "./commands/tail.ts";
+
+const root = Command.make("alchemy", {}).pipe(
+  Command.withSubcommands([
+    bootstrapCommand,
+    deployCommand,
+    destroyCommand,
+    planCommand,
+    tailCommand,
+    logsCommand,
+    loginCommand,
+    profileCommand,
+    stateCommand,
+  ]),
+);
+
+const cli = Command.run(root, {
+  // name: "Alchemy Effect CLI",
+  version: packageJson.version,
+});
+
+const services = Layer.mergeAll(
+  Layer.provideMerge(AlchemyContextLive, PlatformServices),
+  FetchHttpClient.layer,
+  ConfigProvider.layer(ConfigProvider.fromEnv()),
+  TelemetryLive,
+  inkCLI(),
+);
+
+cli.pipe(
+  // $USER and $STAGE are set by the environment
+  Effect.provide(services),
+  Effect.scoped,
+  handleCancellation,
+  runMain,
+);

package/bin/cli.js

@@ -0,0 +1,63 @@
+#!/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 { fileURLToPath } from "node:url";
+import path from "pathe";
+import { foregroundChild } from "foreground-child";
+
+const execpath = (process.env.npm_execpath ?? "").toLowerCase();
+const userAgent = (process.env.npm_config_user_agent ?? "").toLowerCase();
+const invokedByBun = execpath.includes("bun") || userAgent.startsWith("bun/");
+
+// Derive the bin dir from this launcher's own location rather than
+// require.resolve("alchemy/bin/alchemy.js"). The bundled alchemy.js is a
+// build artifact (tsdown output) and may not exist in a fresh checkout
+// (e.g. CI before `bun run build`); resolving it would throw
+// MODULE_NOT_FOUND before we get a chance to fall back to the .ts source.
+const binDir = path.dirname(fileURLToPath(import.meta.url));
+const jsEntry = path.join(binDir, "alchemy.js");
+const tsEntry = path.join(binDir, "alchemy.ts");
+
+// Treat any install-tree path as published; only a raw checkout uses .ts.
+const useTs = !(
+  binDir.includes("/node_modules/") || binDir.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,273 @@
+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 { recordCli } from "../../src/Telemetry/Metrics.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;
+};
+
+/**
+ * Wraps a CLI command handler with a top-level OpenTelemetry span
+ * (`cli.<command>`) and bumps the `alchemy.cli.invocations` counter.
+ *
+ * `attrs` runs against the parsed command args and contributes
+ * additional attributes to the span (e.g. stage, profile, dry-run flag).
+ *
+ * Usage:
+ * ```ts
+ * Command.make(
+ *   "deploy",
+ *   { ...flags },
+ *   instrumentCommand("deploy", (a) => ({
+ *     "alchemy.stage": a.stage,
+ *     "alchemy.profile": a.profile,
+ *   }))(execStack),
+ * );
+ * ```
+ */
+export const instrumentCommand =
+  <AttrsArgs = unknown>(
+    command: string,
+    attrs?: (args: AttrsArgs) => Record<string, unknown>,
+  ) =>
+  <Args extends AttrsArgs, A, E, R>(
+    handler: (args: Args) => Effect.Effect<A, E, R>,
+  ): ((args: Args) => Effect.Effect<A, E, R>) =>
+  (args) =>
+    handler(args).pipe(
+      Effect.withSpan(`cli.${command}`, {
+        attributes: attrs ? attrs(args) : {},
+      }),
+      recordCli(command),
+    );
+
+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,126 @@
+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, instrumentCommand } 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,
+  },
+  instrumentCommand(
+    "bootstrap",
+    (a: { profile: string; region: string | undefined; destroy: boolean }) => ({
+      "alchemy.profile": a.profile,
+      "alchemy.region": a.region ?? "",
+      "alchemy.destroy": a.destroy,
+    }),
+  )(
+    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));
+    }),
+  ),
+);