alchemy 2.0.0-beta.76 → 2.0.0-beta.77

package/src/Cli/commands/dev.ts

@@ -8,9 +8,18 @@ import * as ChildProcess from "effect/unstable/process/ChildProcess";
 import { fileURLToPath } from "node:url";
 import { SPAWNER_URL_ENV_KEY } from "../../Local/RpcProviderProxy.ts";
 import * as RpcSpawner from "../../Local/RpcSpawner.ts";
-import { transformTypesFlags } from "../../Util/Node.ts";
-import { envFile, force, profile, script, stage } from "./_shared.ts";
-import { ExecStackOptions } from "./deploy.ts";
+import { nodeLoaderArgs } from "../../Util/Node.ts";
+import { DEV_RELOAD_EXIT_CODE, DevOptions } from "../DevOptions.ts";
+import {
+  configPath,
+  envFile,
+  force,
+  devStage,
+  optionalConfig,
+  profile,
+  resolveStackArgs,
+} from "./flags.ts";
+import { suppressInterruptMessages } from "./errors.ts";
 
 /**
  * Trust the Floci emulator CA in `alchemy dev` so cross-cloud data planes
@@ -28,19 +37,20 @@ export const devCommand = Command.make(
   "dev",
   {
     force,
-    main: script,
+    config: optionalConfig,
+    configPath,
     envFile,
-    stage,
+    stage: devStage,
     profile,
   },
   Effect.fn(
-    function* (args) {
-      const options = yield* Schema.encodeEffect(ExecStackOptions)({
-        ...args,
-        yes: true,
-        dev: true,
-      });
-
+    function* (rawArgs) {
+      const args = yield* resolveStackArgs("dev")(rawArgs);
+      // This process is only the exec child's supervisor; the child owns the
+      // terminal and announces the Ctrl+C shutdown. Without this, a SIGINT
+      // hits both processes and the interrupt message prints twice.
+      yield* suppressInterruptMessages;
+      const options = yield* Schema.encodeEffect(DevOptions)(args);
       const fs = yield* FileSystem.FileSystem;
       // Set on THIS process too, so the RPC spawner's sidecars (and the workerd
       // they launch) inherit it — they are forked from here, not from the exec
@@ -49,26 +59,44 @@ export const devCommand = Command.make(
         process.env.NODE_EXTRA_CA_CERTS ??= Floci.FLOCI_CA_PATH;
       }
       const spawner = yield* RpcSpawner.RpcSpawner;
-      // We no longer force Bun in development because this prevents us from testing in Node.
-      const command =
-        typeof globalThis.Bun !== "undefined"
-          ? [
-              "bun",
-              "run",
-              ...process.execArgv,
-              "--watch",
-              "--no-clear-screen",
-              fileURLToPath(import.meta.resolve("alchemy/bin/exec.ts")),
-            ]
-          : [
-              "node",
-              ...process.execArgv,
-              ...transformTypesFlags(),
-              "--watch",
-              "--watch-preserve-output",
-              fileURLToPath(import.meta.resolve("alchemy/bin/exec.js")),
-            ];
-      const child = yield* ChildProcess.make(command[0], command.slice(1), {
+      // Neither runtime uses its native `--watch`: those hard-restart the exec
+      // child with no teardown, leaving the previous generation's widget in
+      // scrollback and never saying what changed. exec.ts watches the user's
+      // stack graph itself. Under Node it reloads the graph in-process; under
+      // Bun (which cannot evict evaluated modules) it tears down and exits
+      // with DEV_RELOAD_EXIT_CODE, and this supervisor starts a fresh child.
+      let command: [string, ...string[]];
+      if (typeof globalThis.Bun !== "undefined") {
+        command = [
+          "bun",
+          "run",
+          ...process.execArgv,
+          fileURLToPath(import.meta.resolve("alchemy/bin/exec.ts")),
+        ];
+      } else {
+        // Node: the exec entry runs with alchemy's Oxc loader hooks,
+        // exactly as bin/cli.js started this process (checkout: the
+        // .ts entry plus src-condition resolution; published: the .js
+        // bundle plus the loader for the user's stack). Node's own
+        // TypeScript support is never relied on. `process.execPath`,
+        // not "node": the hooks are gated on THIS node's version. A
+        // duplicate --import inherited via execArgv is harmless — the
+        // second import of the same URL hits the module cache.
+        const entry = fileURLToPath(
+          import.meta.resolve(
+            import.meta.url.endsWith(".ts")
+              ? "alchemy/bin/exec.ts"
+              : "alchemy/bin/exec.js",
+          ),
+        );
+        command = [
+          process.execPath,
+          ...process.execArgv,
+          ...nodeLoaderArgs(entry),
+          entry,
+        ];
+      }
+      const runChild = ChildProcess.make(command[0], command.slice(1), {
         stdin: "inherit",
         stdout: "inherit",
         stderr: "inherit",
@@ -81,9 +109,19 @@ export const devCommand = Command.make(
           [SPAWNER_URL_ENV_KEY]: spawner.url,
         },
         extendEnv: true,
+        // Same process group as this supervisor: the exec child owns the
+        // terminal (TUI stdin), so the tty's Ctrl+C must reach it directly.
         detached: false,
+      }).pipe(
+        Effect.flatMap((child) => child.exitCode),
+        Effect.scoped,
+      );
+      // Each child gets its own scope so a reload exit releases the old
+      // handle before the replacement starts; the sidecar spawner lives in
+      // the command scope and survives every restart.
+      yield* Effect.repeat(runChild, {
+        until: (code) => code !== DEV_RELOAD_EXIT_CODE,
       });
-      yield* child.exitCode;
     },
     (effect, args) =>
       Effect.provide(
@@ -93,4 +131,4 @@ export const devCommand = Command.make(
         }),
       )(effect),
   ),
-);
+).pipe(Command.withDescription("Develop a stack with live reload"));

package/src/Cli/commands/drift.ts

@@ -0,0 +1,107 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Command from "effect/unstable/cli/Command";
+import * as Flag from "effect/unstable/cli/Flag";
+
+import * as Drift from "../../Alchemist/routes/drift.ts";
+import { Cli } from "../../Report.ts";
+import * as CliKit from "../CliKit/index.ts";
+import { planDecisionScreen } from "../components/view/PlanDecision.tsx";
+
+import { config, envFile, profile, resolveStage, stage } from "./flags.ts";
+import { instrumentCommand } from "./instrument.ts";
+import { renderApply, renderPlanning } from "./render.ts";
+
+const repairFlag = Flag.boolean("repair").pipe(
+  Flag.withDescription("Repair detected drift without prompting"),
+  Flag.withDefault(false),
+);
+
+interface SyncArgs {
+  main: string;
+  stage: string;
+  envFile: Option.Option<string>;
+  profile?: string;
+  repair?: boolean;
+}
+
+const routeDrift = Effect.fn(function* ({
+  main,
+  stage,
+  envFile,
+  profile,
+  repair = false,
+}: SyncArgs) {
+  const cli = yield* Cli;
+  const snapshot = yield* Drift.inspect({
+    entrypoint: main,
+    stage,
+    profile,
+    envFile: Option.getOrUndefined(envFile),
+  }).pipe(
+    renderPlanning({
+      operation: "Drift",
+      stage,
+      computingLabel: "Checking drift",
+      readyLabel: "Drift check complete",
+    }),
+  );
+  if (!Drift.hasDrift(snapshot)) {
+    return yield* cli.displayPlan(snapshot.repairPlan.native);
+  }
+
+  if (!repair) {
+    const terminal = yield* CliKit.CliKit;
+    if (!terminal.terminal.input) {
+      return yield* cli.displayPlan(snapshot.repairPlan.native);
+    }
+    const decision = yield* terminal.prompt
+      .custom(
+        planDecisionScreen({
+          plan: snapshot.repairPlan.native,
+          message: "Drift detected",
+          choices: [
+            {
+              value: "repair" as const,
+              label: "Repair",
+            },
+            {
+              value: "cancel" as const,
+              label: "Cancel",
+            },
+          ],
+          initialValue: "cancel" as const,
+        }),
+      )
+      .pipe(
+        Effect.catchTag("TerminalCancelled", () =>
+          Effect.succeed("cancel" as const),
+        ),
+      );
+    if (decision === "cancel") return;
+  }
+
+  yield* Drift.repair(snapshot).pipe(renderApply(snapshot.repairPlan.native));
+});
+
+export const driftCommand = Command.make(
+  "drift",
+  {
+    repair: repairFlag,
+    main: config,
+    envFile,
+    stage,
+    profile,
+  },
+  (args) =>
+    resolveStage("live", args.stage, args.envFile).pipe(
+      Effect.flatMap((stage) =>
+        instrumentCommand("drift", (a: SyncArgs & { repair: boolean }) => ({
+          "alchemy.stage": a.stage,
+          "alchemy.profile": a.profile,
+          "alchemy.main": a.main,
+          "alchemy.repair": a.repair,
+        }))((resolved) => routeDrift(resolved))({ ...args, stage }),
+      ),
+    ),
+).pipe(Command.withDescription("Detect infrastructure drift"));

package/src/Cli/commands/errors.ts

@@ -0,0 +1,162 @@
+import * as Cause from "effect/Cause";
+import * as Console from "effect/Console";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Runtime from "effect/Runtime";
+import * as CliError from "effect/unstable/cli/CliError";
+import { isUserFacing, UserFacingError } from "../../UserFacingError.ts";
+import {
+  ANSI_DIM,
+  ANSI_RESET,
+  ansiFg,
+  colorsEnabled,
+  glyphsFor,
+  theme,
+  unicodeEnabled,
+} from "../CliKit/index.ts";
+
+const isTerminalCancelled = Schema.is(
+  Schema.Struct({ _tag: Schema.Literals(["TerminalCancelled"]) }),
+);
+const isAuthErrorLike = Schema.is(
+  Schema.Struct({
+    _tag: Schema.Literals(["AuthError"]),
+    cause: Schema.optional(Schema.Unknown),
+  }),
+);
+
+export const isPromptCancellation = (error: unknown): boolean => {
+  for (let current = error, depth = 0; current != null && depth < 16; depth++) {
+    if (isTerminalCancelled(current)) return true;
+    if (!isAuthErrorLike(current)) return false;
+    current = current.cause;
+  }
+  return false;
+};
+
+export const EXIT_CANCELLED = 130;
+
+export const setExitCode = (code: number) =>
+  Effect.sync(() => {
+    process.exitCode = code;
+  });
+
+export const exitDeclined = setExitCode(1);
+
+let interruptMessagesSuppressed = false;
+export const suppressInterruptMessages = Effect.sync(() => {
+  interruptMessagesSuppressed = true;
+});
+
+const SHUTDOWN_FEEDBACK_DELAY_MS = 500;
+
+/**
+ * Keep quick shutdowns quiet, but acknowledge cleanup that takes long enough
+ * to be noticeable. The Effect runtime continues to own signal handling and
+ * teardown; this listener only writes delayed feedback.
+ */
+export const installShutdownFeedback = Effect.sync(() => {
+  let scheduled = false;
+  const onSignal = () => {
+    if (scheduled || interruptMessagesSuppressed) return;
+    scheduled = true;
+    const timer = setTimeout(() => {
+      process.stderr.write(
+        colorsEnabled()
+          ? `\n${ANSI_DIM}Shutting down${ANSI_RESET}\n`
+          : "\nShutting down\n",
+      );
+    }, SHUTDOWN_FEEDBACK_DELAY_MS);
+    timer.unref();
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+});
+
+export const handleCancellation = <A, E, R>(self: Effect.Effect<A, E, R>) =>
+  self.pipe(
+    Effect.catchCause((cause) => {
+      const cancelled = cause.reasons.some((reason) => {
+        if (Cause.isFailReason(reason))
+          return isPromptCancellation(reason.error);
+        if (Cause.isDieReason(reason))
+          return isPromptCancellation(reason.defect);
+        return false;
+      });
+      return cancelled
+        ? Console.log(
+            colorsEnabled()
+              ? `\n${ANSI_DIM}Cancelled.${ANSI_RESET}`
+              : "\nCancelled.",
+          ).pipe(Effect.andThen(setExitCode(EXIT_CANCELLED)))
+        : (Effect.failCause(cause) as Effect.Effect<never, E, never>);
+    }),
+    Effect.onInterrupt(() =>
+      interruptMessagesSuppressed
+        ? Effect.void
+        : Console.log(
+            colorsEnabled() ? `\n${ANSI_DIM}Exited.${ANSI_RESET}` : "\nExited.",
+          ),
+    ),
+  );
+
+class ReportedCliError {
+  readonly [Runtime.errorReported] = false;
+  constructor(readonly cause: unknown) {}
+}
+
+// `ConfigError` is effect's own class and cannot carry the `UserFacingError`
+// marker. Everything else is matched by the marker alone — new user-facing
+// errors opt in by assigning the symbol, not by growing this list.
+const isUnmarkedUserFacingError = Schema.is(
+  Schema.Struct({
+    _tag: Schema.Literals(["ConfigError"]),
+    message: Schema.String,
+  }),
+);
+
+const isUserFacingError = (
+  error: unknown,
+): error is { readonly message: string } =>
+  isUserFacing(error) || isUnmarkedUserFacingError(error);
+
+export class UserInputError extends Data.TaggedError("UserInputError")<{
+  readonly message: string;
+}> {
+  readonly [UserFacingError] = true;
+}
+
+export const handleUserErrors = <A, E, R>(self: Effect.Effect<A, E, R>) =>
+  self.pipe(
+    Effect.catchCause((cause) => {
+      for (const reason of cause.reasons) {
+        const error = Cause.isFailReason(reason)
+          ? reason.error
+          : Cause.isDieReason(reason)
+            ? reason.defect
+            : undefined;
+        if (isUserFacingError(error)) {
+          const glyphs = glyphsFor(unicodeEnabled());
+          return Console.error(
+            `${colorsEnabled() ? `${ansiFg(theme.color.danger)}${glyphs.error} error:${ANSI_RESET}` : "error:"} ${error.message}`,
+          ).pipe(
+            Effect.flatMap(() => Effect.fail(new ReportedCliError(cause))),
+          ) as Effect.Effect<never, E | ReportedCliError, never>;
+        }
+      }
+      return Effect.failCause(cause) as Effect.Effect<never, E, never>;
+    }),
+  );
+
+export const handleCliErrors = <A, E, R>(self: Effect.Effect<A, E, R>) =>
+  self.pipe(handleCancellation, handleUserErrors);
+
+export const failWithHelp = (commandPath: ReadonlyArray<string>) =>
+  setExitCode(1).pipe(
+    Effect.andThen(
+      Effect.fail(
+        new CliError.ShowHelp({ commandPath: [...commandPath], errors: [] }),
+      ),
+    ),
+  );

package/src/Cli/commands/flags.ts

@@ -0,0 +1,199 @@
+import * as Clock from "effect/Clock";
+import * as Config from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Argument from "effect/unstable/cli/Argument";
+import * as Flag from "effect/unstable/cli/Flag";
+import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
+import { UserInputError } from "./errors.ts";
+
+export const USER = Config.string("USER").pipe(
+  Config.orElse(() => Config.string("USERNAME")),
+  Config.withDefault("unknown"),
+);
+
+export const ALCHEMY_STAGE = Config.string("ALCHEMY_STAGE").pipe(
+  Config.option,
+  Effect.map(Option.getOrUndefined),
+);
+
+const STAGE_NAME_PATTERN = /^[a-z0-9]+([-_a-z0-9]+)*$/i;
+
+const makeStageFlag = (kind: "live" | "dev") =>
+  Flag.string("stage").pipe(
+    Flag.withSchema(
+      Schema.String.check(Schema.isPattern(/^[a-z0-9]+([-_a-z0-9]+)*$/gi)),
+    ),
+    Flag.withDescription(
+      kind === "live"
+        ? "Stage to deploy to. Defaults to $ALCHEMY_STAGE or live_${USER}"
+        : "Stage to use for dev. Defaults to $ALCHEMY_STAGE or dev_${USER}",
+    ),
+    Flag.optional,
+    Flag.map(Option.getOrUndefined),
+  );
+
+/** `--stage` for deploy / destroy / plan / logs / drift. Default: `live_$USER`. */
+export const stage = makeStageFlag("live");
+
+/** `--stage` for `alchemy dev`. Default: `dev_$USER`. */
+export const devStage = makeStageFlag("dev");
+
+/**
+ * Resolve the target stage after the command's dotenv provider is known.
+ * `--stage` wins; otherwise `$ALCHEMY_STAGE` from process env / `--env-file`
+ * / `.env`; otherwise `live_$USER` or `dev_$USER`.
+ *
+ * `$STAGE` is not consulted. Use `$ALCHEMY_STAGE` so stage selection
+ * matches `$ALCHEMY_PROFILE`.
+ */
+export const resolveStage = Effect.fn(function* (
+  kind: "live" | "dev",
+  override: string | undefined,
+  envFile: Option.Option<string>,
+) {
+  if (override) return override;
+  const provider = yield* loadConfigProvider(envFile);
+  const configured = yield* ALCHEMY_STAGE.pipe(
+    Effect.provideService(ConfigProvider.ConfigProvider, provider),
+    Effect.catch(() => Effect.succeed(undefined)),
+  );
+  if (configured !== undefined && configured !== "") {
+    if (!STAGE_NAME_PATTERN.test(configured)) {
+      return yield* new UserInputError({
+        message: `Invalid $ALCHEMY_STAGE '${configured}'. Must match [a-z0-9]+([-_a-z0-9]+)*.`,
+      });
+    }
+    return configured;
+  }
+  return yield* USER.pipe(
+    Effect.map((user) => `${kind}_${user}`),
+    Effect.catch(() => Effect.succeed(`${kind}_unknown`)),
+  );
+});
+
+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.withAlias("y"),
+  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 config = Flag.file("config", { mustExist: true }).pipe(
+  Flag.withDescription("Alchemy entrypoint file (default: alchemy.run.ts)"),
+  Flag.withAlias("c"),
+  Flag.withDefault("alchemy.run.ts"),
+);
+
+export const optionalConfig = Flag.file("config", { mustExist: true }).pipe(
+  Flag.withDescription("Alchemy entrypoint file (default: alchemy.run.ts)"),
+  Flag.withAlias("c"),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+);
+
+export const configPath = Argument.file("config", { mustExist: true }).pipe(
+  Argument.withDescription("Alchemy entrypoint file (default: alchemy.run.ts)"),
+  Argument.optional,
+  Argument.map(Option.getOrUndefined),
+);
+
+export const resolveConfig = <
+  A extends {
+    readonly config: string | undefined;
+    readonly configPath: string | undefined;
+  },
+>(
+  args: A,
+) =>
+  Effect.gen(function* () {
+    if (args.config !== undefined && args.configPath !== undefined) {
+      return yield* new UserInputError({
+        message:
+          "Pass the config path either positionally or with --config, not both.",
+      });
+    }
+    return {
+      ...args,
+      main: args.config ?? args.configPath ?? "alchemy.run.ts",
+    };
+  });
+
+export const resolveStackArgs =
+  (kind: "live" | "dev") =>
+  <
+    A extends {
+      readonly config: string | undefined;
+      readonly configPath: string | undefined;
+      readonly stage: string | undefined;
+      readonly envFile: Option.Option<string>;
+    },
+  >(
+    args: A,
+  ) =>
+    Effect.gen(function* () {
+      const resolved = yield* resolveConfig(args);
+      const stage = yield* resolveStage(kind, args.stage, args.envFile);
+      return { ...resolved, stage };
+    });
+
+export const profile = Flag.string("profile").pipe(
+  Flag.withDescription(
+    "Auth profile to use. Defaults to $ALCHEMY_PROFILE or 'default'.",
+  ),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+);
+
+export const parseSince = (value: string) =>
+  Effect.gen(function* () {
+    const match = value.match(/^(\d+)([smhd])$/);
+    if (match) {
+      const amount = match[1];
+      const unit = match[2];
+      if (amount === undefined || unit === undefined) {
+        return yield* new UserInputError({
+          message: `Invalid --since value: '${value}'.`,
+        });
+      }
+      const num = parseInt(amount, 10);
+      const duration =
+        unit === "s"
+          ? Duration.seconds(num)
+          : unit === "m"
+            ? Duration.minutes(num)
+            : unit === "h"
+              ? Duration.hours(num)
+              : Duration.days(num);
+      const now = yield* Clock.currentTimeMillis;
+      return new Date(now - Duration.toMillis(duration));
+    }
+    const parsed = new Date(value);
+    if (isNaN(parsed.getTime())) {
+      return yield* new UserInputError({
+        message: `Invalid --since value: '${value}'. Use a duration (e.g. '1h', '30m') or ISO date.`,
+      });
+    }
+    return parsed;
+  });

package/src/Cli/commands/instrument.ts

@@ -0,0 +1,18 @@
+import * as Effect from "effect/Effect";
+import { recordCli } from "../../Telemetry/Metrics.ts";
+
+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),
+    );